langfun 0.1.2.dev202510240805__tar.gz → 0.1.2.dev202510250803__tar.gz

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/PKG-INFO

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

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/langfun/core/concurrent_test.py

@@ -608,6 +608,7 @@ class ConcurrentMapTest(unittest.TestCase):
         ],
     )
     concurrent.ProgressBar.uninstall(bar_id)
+    concurrent.ProgressBar.refresh()
     self.assertIn('100%', string_io.getvalue())
 
 

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/langfun/core/data/conversion/anthropic_test.py

@@ -253,14 +253,16 @@ class AnthropicConversionTest(unittest.TestCase):
     )
     self.assertEqual(
         m.text,
-        'What are the common words from <<[[obj0]]>> and <<[[obj1]]>> ?'
+        'What are the common words from <<[[image:dc6e1e43]]>> and'
+        ' <<[[pdf:5daf5f31]]>> ?'
     )
-    self.assertIsInstance(m.obj0, lf_modalities.Image)
-    self.assertEqual(m.obj0.mime_type, 'image/png')
-    self.assertEqual(m.obj0.to_bytes(), image_content)
+    modalities = m.modalities()
+    self.assertIsInstance(modalities[0], lf_modalities.Image)
+    self.assertEqual(modalities[0].mime_type, 'image/png')
+    self.assertEqual(modalities[0].content, image_content)
 
-    self.assertIsInstance(m.obj1, lf_modalities.PDF)
-    self.assertEqual(m.obj1.to_bytes(), pdf_content)
+    self.assertIsInstance(modalities[1], lf_modalities.PDF)
+    self.assertEqual(modalities[1].content, pdf_content)
 
 
 if __name__ == '__main__':

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/langfun/core/data/conversion/gemini_test.py

@@ -225,19 +225,22 @@ class GeminiConversionTest(unittest.TestCase):
     self.assertEqual(
         m.text,
         (
-            'What are the common words from <<[[obj0]]>> , <<[[obj1]]>> '
-            'and <<[[obj2]]>> ?'
+            'What are the common words from <<[[image:dc6e1e43]]>> , '
+            '<<[[pdf:4dc12e93]]>> and <<[[video:7e169565]]>> ?'
         )
     )
-    self.assertIsInstance(m.obj0, lf_modalities.Image)
-    self.assertEqual(m.obj0.mime_type, 'image/png')
-    self.assertEqual(m.obj0.to_bytes(), image_content)
+    self.assertIsInstance(m.modalities()[0], lf_modalities.Image)
+    self.assertEqual(m.modalities()[0].mime_type, 'image/png')
+    self.assertEqual(m.modalities()[0].to_bytes(), image_content)
 
-    self.assertIsInstance(m.obj1, lf_modalities.PDF)
-    self.assertEqual(m.obj1.uri, 'https://my.pdf')
+    self.assertIsInstance(m.modalities()[1], lf_modalities.PDF)
+    self.assertEqual(m.modalities()[1].uri, 'https://my.pdf')
 
-    self.assertIsInstance(m.obj2, lf_modalities.Video)
-    self.assertEqual(m.obj2.uri, 'https://www.youtube.com/watch?v=abcd')
+    self.assertIsInstance(m.modalities()[2], lf_modalities.Video)
+    self.assertEqual(
+        m.modalities()[2].uri,
+        'https://www.youtube.com/watch?v=abcd'
+    )
 
 
 if __name__ == '__main__':

langfun-0.1.2.dev202510250803/langfun/core/data/conversion/openai.py

@@ -0,0 +1,235 @@
+# 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.
+"""OpenAI API message conversion."""
+
+from typing import Annotated, Any, Callable
+
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+
+
+class OpenAIChatCompletionAPIMessageConverter(lf.MessageConverter):
+  """Converter to OpenAI ChatCompletion API.
+
+  See https://platform.openai.com/docs/api-reference/chat
+  """
+
+  FORMAT_ID = 'openai_chat_completion_api'
+
+  chunk_preprocessor: Annotated[
+      Callable[[str | lf.Modality], Any] | None,
+      (
+          'Chunk preprocessor for Langfun chunk to OpenAI chunk conversion. '
+          'It will be applied before each Langfun chunk is converted. '
+          'If returns None, the chunk will be skipped.'
+      )
+  ] = None
+
+  def to_value(self, message: lf.Message) -> dict[str, Any]:
+    """Converts a Langfun message to OpenAI API."""
+    parts = []
+    for chunk in message.chunk():
+      if self.chunk_preprocessor is not None:
+        chunk = self.chunk_preprocessor(chunk)
+        if chunk is None:
+          continue
+      parts.append(self.chunk_to_json(type(message), chunk))
+    return dict(
+        role=self.get_role(message),
+        content=parts,
+    )
+
+  def chunk_to_json(
+      self,
+      message_cls: type[lf.Message],
+      chunk: str | lf.Modality
+  ) -> dict[str, Any]:
+    """Converts a Langfun chunk to OpenAI chunk."""
+    del message_cls
+    if isinstance(chunk, str):
+      return dict(type='text', text=chunk)
+    elif isinstance(chunk, lf_modalities.Image):
+      return dict(
+          type='image_url', image_url=dict(url=chunk.embeddable_uri)
+      )
+    # TODO(daiyip): Support audio_input.
+    else:
+      raise ValueError(f'Unsupported content type: {chunk!r}.')
+
+  def get_role(self, message: lf.Message) -> str:
+    """Returns the role of the message."""
+    if isinstance(message, lf.SystemMessage):
+      return 'system'
+    elif isinstance(message, lf.UserMessage):
+      return 'user'
+    elif isinstance(message, lf.AIMessage):
+      return 'assistant'
+    else:
+      raise ValueError(f'Unsupported message type: {message!r}.')
+
+  def get_message_cls(self, role: str) -> type[lf.Message]:
+    """Returns the message class of the message."""
+    match role:
+      case 'system':
+        return lf.SystemMessage
+      case 'user':
+        return lf.UserMessage
+      case 'assistant':
+        return lf.AIMessage
+      case _:
+        raise ValueError(f'Unsupported role: {role!r}.')
+
+  def from_value(self, value: dict[str, Any]) -> lf.Message:
+    """Returns a Langfun message from OpenAI message."""
+    message_cls = self.get_message_cls(
+        self._safe_read(value, 'role', default='assistant')
+    )
+    content = self._safe_read(value, 'content')
+    if isinstance(content, str):
+      return message_cls(content)
+
+    assert isinstance(content, list)
+    chunks = []
+    for item in content:
+      chunks.append(self.json_to_chunk(item))
+    return message_cls.from_chunks(chunks)
+
+  def json_to_chunk(self, json: dict[str, Any]) -> str | lf.Modality:
+    """Returns a Langfun chunk from OpenAI chunk JSON."""
+    t = self._safe_read(json, 'type')
+    if t == 'text':
+      return self._safe_read(json, 'text')
+    elif t == 'image_url':
+      return lf_modalities.Image.from_uri(
+          self._safe_read(self._safe_read(json, 'image_url'), 'url')
+      )
+    else:
+      raise ValueError(f'Unsupported content type: {json!r}.')
+
+
+def _as_openai_chat_completion_api_format(
+    self,
+    chunk_preprocessor: Callable[[str | lf.Modality], Any] | None = None,
+    **kwargs
+) -> dict[str, Any]:
+  """Returns an OpenAI format message."""
+  return OpenAIChatCompletionAPIMessageConverter(
+      chunk_preprocessor=chunk_preprocessor, **kwargs
+  ).to_value(self)
+
+
+@classmethod
+def _from_openai_chat_completion_api_format(
+    cls,
+    openai_message: dict[str, Any],
+    **kwargs
+) -> lf.Message:
+  """Creates a Langfun message from the OpenAI format message."""
+  del cls
+  return OpenAIChatCompletionAPIMessageConverter(
+      **kwargs
+  ).from_value(openai_message)
+
+# Set shortcut methods in lf.Message.
+lf.Message.as_openai_chat_completion_api_format = (
+    _as_openai_chat_completion_api_format
+)
+
+lf.Message.from_openai_chat_completion_api_format = (
+    _from_openai_chat_completion_api_format
+)
+
+
+#
+# OpenAI Responses API message converter.
+#
+
+
+class OpenAIResponsesAPIMessageConverter(
+    OpenAIChatCompletionAPIMessageConverter
+):
+  """Converter to OpenAI Responses API.
+
+  See https://platform.openai.com/docs/api-reference/responses/create
+  """
+
+  FORMAT_ID = 'openai_responses_api'
+
+  def to_value(self, message: lf.Message) -> dict[str, Any]:
+    """Converts a Langfun message to OpenAI API."""
+    message_json = super().to_value(message)
+    message_json['type'] = 'message'
+    return message_json
+
+  def chunk_to_json(
+      self,
+      message_cls: type[lf.Message],
+      chunk: str | lf.Modality
+  ) -> dict[str, Any]:
+    """Converts a Langfun chunk to OpenAI chunk."""
+    source = 'output' if issubclass(message_cls, lf.AIMessage) else 'input'
+
+    if isinstance(chunk, str):
+      return dict(type=f'{source}_text', text=chunk)
+    elif isinstance(chunk, lf_modalities.Image):
+      return dict(
+          type=f'{source}_image', image_url=chunk.embeddable_uri
+      )
+    # TODO(daiyip): Support audio_input.
+    else:
+      raise ValueError(f'Unsupported content type: {chunk!r}.')
+
+  def json_to_chunk(self, json: dict[str, Any]) -> str | lf.Modality:
+    """Returns a Langfun chunk from OpenAI chunk JSON."""
+    t = self._safe_read(json, 'type')
+    if t in ('input_text', 'output_text'):
+      return self._safe_read(json, 'text')
+    elif t in ('input_image', 'output_image'):
+      return lf_modalities.Image.from_uri(self._safe_read(json, 'image_url'))
+    else:
+      raise ValueError(f'Unsupported content type: {json!r}.')
+
+
+def _as_openai_responses_api_format(
+    self,
+    chunk_preprocessor: Callable[[str | lf.Modality], Any] | None = None,
+    **kwargs
+) -> dict[str, Any]:
+  """Returns an OpenAI format message."""
+  return OpenAIResponsesAPIMessageConverter(
+      chunk_preprocessor=chunk_preprocessor, **kwargs
+  ).to_value(self)
+
+
+@classmethod
+def _from_openai_responses_api_format(
+    cls,
+    openai_message: dict[str, Any],
+    **kwargs
+) -> lf.Message:
+  """Creates a Langfun message from the OpenAI format message."""
+  del cls
+  return OpenAIResponsesAPIMessageConverter(
+      **kwargs
+  ).from_value(openai_message)
+
+
+# Set shortcut methods in lf.Message.
+lf.Message.as_openai_responses_api_format = (
+    _as_openai_responses_api_format
+)
+
+lf.Message.from_openai_responses_api_format = (
+    _from_openai_responses_api_format
+)

langfun-0.1.2.dev202510250803/langfun/core/data/conversion/openai_test.py

@@ -0,0 +1,320 @@
+# 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 base64
+import unittest
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+from langfun.core.data.conversion import openai  # pylint: disable=unused-import
+
+
+image_content = (
+    b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x04'
+    b'\x03\x00\x00\x00\x12Y \xcb\x00\x00\x00\x18PLTE\x00\x00'
+    b'\x00fff_chaag_cg_ch^ci_ciC\xedb\x94\x00\x00\x00\x08tRNS'
+    b'\x00\n\x9f*\xd4\xff_\xf4\xe4\x8b\xf3a\x00\x00\x00>IDATx'
+    b'\x01c \x05\x08)"\xd8\xcc\xae!\x06pNz\x88k\x19\\Q\xa8"\x10'
+    b'\xc1\x14\x95\x01%\xc1\n\xa143Ta\xa8"D-\x84\x03QM\x98\xc3'
+    b'\x1a\x1a\x1a@5\x0e\x04\xa0q\x88\x05\x00\x07\xf8\x18\xf9'
+    b'\xdao\xd0|\x00\x00\x00\x00IEND\xaeB`\x82'
+)
+
+
+class OpenAIChatCompletionAPIConverterTest(unittest.TestCase):
+
+  def test_as_format_with_role(self):
+    self.assertEqual(
+        lf.UserMessage('hi').as_format('openai_chat_completion_api'),
+        {
+            'role': 'user',
+            'content': [{'type': 'text', 'text': 'hi'}],
+        },
+    )
+    self.assertEqual(
+        lf.AIMessage('hi').as_format('openai_chat_completion_api'),
+        {
+            'role': 'assistant',
+            'content': [{'type': 'text', 'text': 'hi'}],
+        },
+    )
+    self.assertEqual(
+        lf.SystemMessage('hi').as_format('openai_chat_completion_api'),
+        {
+            'role': 'system',
+            'content': [{'type': 'text', 'text': 'hi'}],
+        },
+    )
+
+  def test_as_format_with_image(self):
+    self.assertEqual(
+        lf.Template(
+            'What is this {{image}}?',
+            image=lf_modalities.Image.from_bytes(image_content)
+        ).render().as_format('openai_chat_completion_api'),
+        {
+            'role': 'user',
+            'content': [
+                {
+                    'type': 'text',
+                    'text': 'What is this'
+                },
+                {
+                    'type': 'image_url',
+                    'image_url': {
+                        'url': (
+                            'data:image/png;base64,'
+                            + base64.b64encode(image_content).decode('utf-8')
+                        )
+                    }
+                },
+                {
+                    'type': 'text',
+                    'text': '?'
+                }
+            ],
+        },
+    )
+
+  def test_as_format_with_chunk_preprocessor(self):
+    self.assertEqual(
+        lf.Template(
+            'What is this {{image}}?',
+            image=lf_modalities.Image.from_bytes(image_content)
+        ).render().as_openai_chat_completion_api_format(
+            chunk_preprocessor=lambda x: x if isinstance(x, str) else None
+        ),
+        {
+            'role': 'user',
+            'content': [
+                {
+                    'type': 'text',
+                    'text': 'What is this'
+                },
+                {
+                    'type': 'text',
+                    'text': '?'
+                }
+            ],
+        },
+    )
+
+  def test_from_value_with_simple_text(self):
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'content': 'this is a text',
+            },
+            format='openai_chat_completion_api',
+        ),
+        lf.AIMessage('this is a text'),
+    )
+
+  def test_from_value_with_role(self):
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'user',
+                'content': [{'type': 'text', 'text': 'hi'}],
+            },
+            format='openai_chat_completion_api',
+        ),
+        lf.UserMessage('hi'),
+    )
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'assistant',
+                'content': [{'type': 'text', 'text': 'hi'}],
+            },
+            format='openai_chat_completion_api',
+        ),
+        lf.AIMessage('hi'),
+    )
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'system',
+                'content': [{'type': 'text', 'text': 'hi'}],
+            },
+            format='openai_chat_completion_api',
+        ),
+        lf.SystemMessage('hi'),
+    )
+    with self.assertRaisesRegex(ValueError, 'Unsupported role: .*'):
+      lf.Message.from_value(
+          {
+              'role': 'function',
+              'content': [{'type': 'text', 'text': 'hi'}],
+          },
+          format='openai_chat_completion_api',
+      )
+
+  def test_from_value_with_image(self):
+    image = lf_modalities.Image.from_bytes(image_content)
+    m = lf.Message.from_openai_chat_completion_api_format(
+        lf.Template(
+            'What is this {{image}}?',
+            image=image
+        ).render().as_format('openai_chat_completion_api'),
+    )
+    self.assertEqual(m.text, f'What is this <<[[{image.id}]]>> ?')
+    self.assertIsInstance(m.images[0], lf_modalities.Image)
+    self.assertEqual(m.images[0].mime_type, 'image/png')
+    self.assertEqual(m.images[0].to_bytes(), image_content)
+
+
+class OpenAIResponsesAPIMessageConverterTest(unittest.TestCase):
+
+  def test_as_format_with_role(self):
+    self.assertEqual(
+        lf.UserMessage('hi').as_format('openai_responses_api'),
+        {
+            'type': 'message',
+            'role': 'user',
+            'content': [{'type': 'input_text', 'text': 'hi'}],
+        },
+    )
+    self.assertEqual(
+        lf.AIMessage('hi').as_format('openai_responses_api'),
+        {
+            'type': 'message',
+            'role': 'assistant',
+            'content': [{'type': 'output_text', 'text': 'hi'}],
+        },
+    )
+    self.assertEqual(
+        lf.SystemMessage('hi').as_format('openai_responses_api'),
+        {
+            'type': 'message',
+            'role': 'system',
+            'content': [{'type': 'input_text', 'text': 'hi'}],
+        },
+    )
+
+  def test_as_format_with_image(self):
+    self.assertEqual(
+        lf.Template(
+            'What is this {{image}}?',
+            image=lf_modalities.Image.from_bytes(image_content)
+        ).render().as_format('openai_responses_api'),
+        {
+            'type': 'message',
+            'role': 'user',
+            'content': [
+                {
+                    'type': 'input_text',
+                    'text': 'What is this'
+                },
+                {
+                    'type': 'input_image',
+                    'image_url': (
+                        'data:image/png;base64,'
+                        + base64.b64encode(image_content).decode('utf-8')
+                    )
+                },
+                {
+                    'type': 'input_text',
+                    'text': '?'
+                }
+            ],
+        },
+    )
+
+  def test_as_format_with_chunk_preprocessor(self):
+    self.assertEqual(
+        lf.Template(
+            'What is this {{image}}?',
+            image=lf_modalities.Image.from_bytes(image_content)
+        ).render().as_openai_responses_api_format(
+            chunk_preprocessor=lambda x: x if isinstance(x, str) else None
+        ),
+        {
+            'type': 'message',
+            'role': 'user',
+            'content': [
+                {
+                    'type': 'input_text',
+                    'text': 'What is this'
+                },
+                {
+                    'type': 'input_text',
+                    'text': '?'
+                }
+            ],
+        },
+    )
+
+  def test_from_value_with_simple_text(self):
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'content': 'this is a text',
+            },
+            format='openai_responses_api',
+        ),
+        lf.AIMessage('this is a text'),
+    )
+
+  def test_from_value_with_role(self):
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'user',
+                'content': [{'type': 'input_text', 'text': 'hi'}],
+            },
+            format='openai_responses_api',
+        ),
+        lf.UserMessage('hi'),
+    )
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'assistant',
+                'content': [{'type': 'output_text', 'text': 'hi'}],
+            },
+            format='openai_responses_api',
+        ),
+        lf.AIMessage('hi'),
+    )
+    self.assertEqual(
+        lf.Message.from_value(
+            {
+                'role': 'system',
+                'content': [{'type': 'input_text', 'text': 'hi'}],
+            },
+            format='openai_responses_api',
+        ),
+        lf.SystemMessage('hi'),
+    )
+    with self.assertRaisesRegex(ValueError, 'Unsupported role: .*'):
+      lf.Message.from_value(
+          {
+              'role': 'function',
+              'content': [{'type': 'input_text', 'text': 'hi'}],
+          },
+          format='openai_responses_api',
+      )
+
+  def test_from_value_with_image(self):
+    image = lf_modalities.Image.from_bytes(image_content)
+    m = lf.Message.from_openai_responses_api_format(
+        lf.Template(
+            'What is this {{image}}?', image=image
+        ).render().as_format('openai_responses_api'),
+    )
+    self.assertEqual(m.text, f'What is this <<[[{image.id}]]>> ?')
+    self.assertIsInstance(m.modalities()[0], lf_modalities.Image)
+    self.assertEqual(m.modalities()[0].content, image_content)
+
+if __name__ == '__main__':
+  unittest.main()

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/langfun/core/eval/v2/progress_tracking_test.py

@@ -18,6 +18,7 @@ import sys
 import tempfile
 import unittest
 
+from langfun.core import concurrent as lf_concurrent
 from langfun.core import console as lf_console
 from langfun.core.eval.v2 import eval_test_helper
 from langfun.core.eval.v2 import progress_tracking    # pylint: disable=unused-import
@@ -51,6 +52,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', plugins=[])
       sys.stderr.flush()
+    lf_concurrent.ProgressBar.refresh()
     self.assertIn('All: 100%', string_io.getvalue())
 
   def test_with_example_ids(self):
@@ -62,6 +64,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', example_ids=[1], plugins=[])
       sys.stderr.flush()
+    lf_concurrent.ProgressBar.refresh()
     self.assertIn('All: 100%', string_io.getvalue())
 
 

{langfun-0.1.2.dev202510240805 → langfun-0.1.2.dev202510250803}/langfun/core/langfunc_test.py

@@ -82,7 +82,7 @@ class LangFuncCallTest(unittest.TestCase):
 
     i = l.render()
     self.assertEqual(i, 'Hello')
-    self.assertEqual(i, message.UserMessage('Hello'))
+    self.assertEqual(i, message.UserMessage('Hello', __template_input__={}))
     self.assertEqual(i.tags, ['rendered'])
 
     r = l()
@@ -96,7 +96,9 @@ class LangFuncCallTest(unittest.TestCase):
     self.assertEqual(r.tags, ['lm-response', 'lm-output'])
     self.assertEqual(
         r.source,
-        message.UserMessage('Hello', metadata=dict(cache_seed=0))
+        message.UserMessage(
+            'Hello', metadata=dict(cache_seed=0, __template_input__={})
+        )
     )
     self.assertEqual(r.source.tags, ['rendered', 'lm-input'])