langfun 0.1.2.dev202510160805__tar.gz → 0.1.2.dev202510170805__tar.gz

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510160805
+Version: 0.1.2.dev202510170805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,11 +21,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anyio>=4.7.0
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: puremagic>=1.20
 Requires-Dist: pyglove>=0.4.5.dev202507140812
 Requires-Dist: requests>=2.31.0
 Provides-Extra: all
+Requires-Dist: anyio>=4.7.0; extra == "all"
 Requires-Dist: jinja2>=3.1.2; extra == "all"
 Requires-Dist: puremagic>=1.20; extra == "all"
 Requires-Dist: pyglove>=0.4.5.dev202507140812; extra == "all"

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun/core/__init__.py

@@ -40,9 +40,13 @@ from langfun.core.component import context
 as_context = context
 use_context = context
 
-# Invoke a callable object asynchronously.
+# Support for async IO.
 from langfun.core.async_support import invoke_async
 
+# Adaptors for async function/context manager to sync versions.
+from langfun.core.async_support import invoke_sync
+from langfun.core.async_support import sync_context_manager
+
 # Shortcut function for overriding components attributes, usually for
 # override settings.
 from langfun.core.component import use_settings

langfun-0.1.2.dev202510170805/langfun/core/async_support.py

@@ -0,0 +1,98 @@
+# 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
+import contextlib
+from typing import Any, Awaitable, Callable, Iterator
+import anyio
+import pyglove as pg
+
+
+async def invoke_async(
+    sync_callable: 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(sync_callable), *args, **kwargs
+  )
+
+
+def invoke_sync(
+    async_callable: Callable[..., Awaitable[Any]],
+    *args,
+    **kwargs
+) -> Any:
+  """Invokes a async callable synchronously."""
+  async def _invoke():
+    return await async_callable(*args, **kwargs)
+  invoke_fn = pg.with_contextual_override(_invoke)
+  blocking_portal = pg.utils.thread_local_get('__blocking_portal__', None)
+  if blocking_portal is None:
+    return anyio.run(invoke_fn)
+  return blocking_portal.call(invoke_fn)
+
+
+@contextlib.contextmanager
+def sync_context_manager(
+    async_context_manager: contextlib.AbstractAsyncContextManager[Any]
+) -> Iterator[Any]:
+  """Adapts an async context manager to a sync context manager.
+
+  sync_context_manager installs a blocking portal in current thread to run the
+  async context manager in a blocking way. It's useful for running async code in
+  sync context managers, e.g. `sync_context_manager` can be nested and share the
+  same event loop.
+
+  Example:
+
+    ```python
+    @contextlib.asynccontextmanager
+    async def foo(x):
+      try:
+        yield x
+      finally:
+        pass
+
+    with lf.sync_context_manager(foo(x)) as x
+      with lf.sync_context_manager(foo(y)) as y:
+        ...
+    ```
+
+  Args:
+    async_context_manager: The async context manager to adapt.
+
+  Yields:
+    The value yielded by the async context manager.
+  """
+  blocking_portal = pg.utils.thread_local_get('__blocking_portal__', None)
+  portal_exit_stack = None
+
+  try:
+    if blocking_portal is None:
+      portal_exit_stack = contextlib.ExitStack()
+      blocking_portal = portal_exit_stack.enter_context(
+          anyio.from_thread.start_blocking_portal()
+      )
+      pg.utils.thread_local_set('__blocking_portal__', blocking_portal)
+    context_manager = blocking_portal.wrap_async_context_manager(
+        async_context_manager
+    )
+    with context_manager as value:
+      yield value
+  finally:
+    if portal_exit_stack is not None:
+      portal_exit_stack.close()
+      pg.utils.thread_local_del('__blocking_portal__')

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun/core/async_support_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import contextlib
 import time
 import unittest
 
@@ -34,6 +35,28 @@ class AsyncSupportTest(unittest.TestCase):
     with pg.contextual_override(z=3):
       self.assertEqual(asyncio.run(r), 6)
 
+  def test_invoke_sync(self):
+    @contextlib.asynccontextmanager
+    async def bar(x):
+      try:
+        yield x
+      finally:
+        pass
+
+    async def foo(x, *, y):
+      time.sleep(2)
+      return x + y + pg.contextual_value('z', 0)
+
+    with pg.contextual_override(z=3):
+      with async_support.sync_context_manager(bar(1)) as x:
+        self.assertEqual(x, 1)
+        with async_support.sync_context_manager(bar(2)) as y:
+          self.assertEqual(y, 2)
+          self.assertEqual(async_support.invoke_sync(foo, 1, y=2), 6)
+
+    with pg.contextual_override(z=2):
+      self.assertEqual(async_support.invoke_sync(foo, 1, y=2), 5)
+
 
 if __name__ == '__main__':
   unittest.main()

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun/core/concurrent_test.py

@@ -262,6 +262,7 @@ class ProgressControlTest(unittest.TestCase):
     with contextlib.redirect_stderr(string_io):
       ctrl.update(1)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertEqual(string_io.getvalue(), '')
     concurrent.progress_bar = 'tqdm'
 
@@ -274,6 +275,7 @@ class ProgressControlTest(unittest.TestCase):
       ctrl.set_status('bar')
       ctrl.update(10)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertEqual(
         string_io.getvalue(),
         '\x1b[1m\x1b[31mfoo\x1b[0m: \x1b[34m10% (10/100)\x1b[0m : bar\n'
@@ -288,6 +290,7 @@ class ProgressControlTest(unittest.TestCase):
       self.assertIsInstance(ctrl, concurrent._TqdmProgressControl)
       ctrl.update(10)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertIn('10/100', string_io.getvalue())
 
     tqdm = concurrent.tqdm
@@ -316,6 +319,7 @@ class ProgressBarTest(unittest.TestCase):
       for _ in concurrent.concurrent_execute(fun, range(5)):
         concurrent.ProgressBar.refresh()
       concurrent.ProgressBar.uninstall(bar_id)
+      sys.stderr.flush()
     output_str = string_io.getvalue()
     self.assertIn('100%', output_str)
     self.assertIn('5/5', output_str)
@@ -332,7 +336,7 @@ class ProgressBarTest(unittest.TestCase):
         concurrent.ProgressBar.update(bar_id, 0, status=1)
       concurrent.ProgressBar.uninstall(bar_id)
       sys.stderr.flush()
-      time.sleep(1)
+    time.sleep(1)
     self.assertIn('1/4', string_io.getvalue())
     # TODO(daiyip): Re-enable once flakiness is fixed.
     # self.assertIn('2/4', string_io.getvalue())
@@ -564,7 +568,8 @@ class ConcurrentMapTest(unittest.TestCase):
               fun, [1, 2, 3], timeout=1.5, max_workers=1, show_progress=True
           )
       ], key=lambda x: x[0])
-      string_io.flush()
+      sys.stderr.flush()
+
     self.assertEqual(   # pylint: disable=g-generic-assert
         output,
         [
@@ -592,6 +597,7 @@ class ConcurrentMapTest(unittest.TestCase):
               show_progress=bar_id, status_fn=lambda p: dict(x=1, y=1)
           )
       ], key=lambda x: x[0])
+      sys.stderr.flush()
 
     self.assertEqual(  # pylint: disable=g-generic-assert
         output,

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun/core/eval/v2/progress_tracking_test.py

@@ -50,7 +50,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     string_io = io.StringIO()
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', plugins=[])
-    sys.stderr.flush()
+      sys.stderr.flush()
     self.assertIn('All: 100%', string_io.getvalue())
 
   def test_with_example_ids(self):
@@ -61,7 +61,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     string_io = io.StringIO()
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', example_ids=[1], plugins=[])
-    sys.stderr.flush()
+      sys.stderr.flush()
     self.assertIn('All: 100%', string_io.getvalue())
 
 

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510160805
+Version: 0.1.2.dev202510170805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,11 +21,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anyio>=4.7.0
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: puremagic>=1.20
 Requires-Dist: pyglove>=0.4.5.dev202507140812
 Requires-Dist: requests>=2.31.0
 Provides-Extra: all
+Requires-Dist: anyio>=4.7.0; extra == "all"
 Requires-Dist: jinja2>=3.1.2; extra == "all"
 Requires-Dist: puremagic>=1.20; extra == "all"
 Requires-Dist: pyglove>=0.4.5.dev202507140812; extra == "all"

{langfun-0.1.2.dev202510160805 → langfun-0.1.2.dev202510170805}/langfun.egg-info/requires.txt

@@ -1,9 +1,11 @@
+anyio>=4.7.0
 jinja2>=3.1.2
 puremagic>=1.20
 pyglove>=0.4.5.dev202507140812
 requests>=2.31.0
 
 [all]
+anyio>=4.7.0
 jinja2>=3.1.2
 puremagic>=1.20
 pyglove>=0.4.5.dev202507140812

langfun-0.1.2.dev202510160805/langfun/core/async_support.py

@@ -1,28 +0,0 @@
-# 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
-  )