langfun 0.1.2.dev202511030805__tar.gz → 0.1.2.dev202511040805__tar.gz

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/PKG-INFO

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

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/message.py

@@ -239,6 +239,11 @@ class Message(
     """
     return MessageConverter.get(format_or_type, **kwargs).to_value(self)
 
+  @classmethod
+  def is_convertible(cls, format_or_type: str | Type[Any]) -> bool:
+    """Returns True if the value can be converted to a message."""
+    return MessageConverter.is_convertible(format_or_type)
+
   @classmethod
   def convertible_formats(cls) -> list[str]:
     """Returns supported format for message conversion."""
@@ -938,6 +943,13 @@ class _MessageConverterRegistry:
     assert isinstance(format_or_type, type), format_or_type
     return self.get_by_type(format_or_type, **kwargs)
 
+  def is_convertible(self, format_or_type: str | Type[Any]) -> bool:
+    """Returns whether the message is convertible to the given format or type."""
+    if isinstance(format_or_type, str):
+      return format_or_type in self._name_to_converter
+    assert isinstance(format_or_type, type), format_or_type
+    return format_or_type in self._type_to_converters
+
   def convertible_formats(self) -> list[str]:
     """Returns a list of converter names."""
     return sorted(list(self._name_to_converter.keys()))
@@ -1029,6 +1041,11 @@ class MessageConverter(pg.Object):
     """Returns a message converter for the given type."""
     return cls._REGISTRY.get_by_type(t, **kwargs)
 
+  @classmethod
+  def is_convertible(cls, format_or_type: str | Type[Any]) -> bool:
+    """Returns whether the message is convertible to the given format or type."""
+    return cls._REGISTRY.is_convertible(format_or_type)
+
   @classmethod
   def convertible_formats(cls) -> list[str]:
     """Returns a list of converter names."""

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/message_test.py

@@ -500,6 +500,12 @@ class MessageConverterTest(unittest.TestCase):
     self.assertIn('test_format2', message.Message.convertible_formats())
     self.assertIn('test_format3', message.Message.convertible_formats())
 
+    self.assertTrue(message.Message.is_convertible(int))
+    self.assertFalse(message.Message.is_convertible(dict))
+    self.assertTrue(message.Message.is_convertible('test_format1'))
+    self.assertTrue(message.Message.is_convertible('test_format2'))
+    self.assertTrue(message.Message.is_convertible('test_format3'))
+    self.assertFalse(message.Message.is_convertible('test_format4'))
     self.assertIn(int, message.Message.convertible_types())
     self.assertIn(tuple, message.Message.convertible_types())
     self.assertEqual(

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/modalities/mime.py

@@ -49,6 +49,10 @@ class Mime(lf.Modality):
       Union[str, bytes, None], 'The raw content of the MIME type.'
   ] = None
 
+  metadata: Annotated[
+      dict[str, Any], 'Additional metadata attached to this object.'
+  ] = {}
+
   @functools.cached_property
   def mime_type(self) -> str:
     """Returns the MIME type."""
@@ -94,7 +98,10 @@ class Mime(lf.Modality):
     # Hash the URI to avoid downloading the content.
     if self.uri is not None:
       return hashlib.md5(self.uri.encode()).hexdigest()[:8]
-    return super().hash
+    if self.content is not None:
+      return super().hash
+    assert self.metadata
+    return hashlib.md5(str(self.metadata).encode()).hexdigest()[:8]
 
   def to_text(self) -> str:
     """Returns the text content of the MIME type."""
@@ -141,7 +148,7 @@ class Mime(lf.Modality):
 
   def _on_bound(self):
     super()._on_bound()
-    if self.uri is None and self.content is None:
+    if self.uri is None and self.content is None and not self.metadata:
       raise ValueError('Either uri or content must be provided.')
 
   def to_bytes(self) -> bytes:

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/structured/parsing_test.py

@@ -745,9 +745,6 @@ class CallTest(unittest.TestCase):
         parsing.call('what is one plus two?', int, lm=lm, autofix=3), 3
     )
 
-  def test_call_with_structured_input(self):
-    self.assertEqual(parsing.call(1, lm=fake.StaticResponse('2')), '2')
-
   def test_call_with_response_postprocess(self):
     target_str = '@TARGET_STR@'
     random_str = '!RANDOM_STR!'

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/template.py

@@ -540,17 +540,19 @@ class Template(
       return value.clone(override=kwargs) if kwargs else value  # pylint: disable=no-value-for-parameter
     if isinstance(value, str):
       return cls(template_str=value, **kwargs)
+    if isinstance(value, Template):
+      lfun = cls(template_str=value.template_str, **kwargs)  # pylint: disable=attribute-error
+      # So lfun could acccess all attributes from value.
+      lfun.sym_setparent(value)
+      return lfun
+    if message_lib.Message.is_convertible(type(value)):
+      value = message_lib.Message.from_value(value)
     if isinstance(value, message_lib.Message):
       for k, v in value.metadata.sym_items():  # pylint: disable=attribute-error
         kwargs[_ADDITIONAL_METADATA_PREFIX + k] = v
       t = cls(template_str=value.text, **kwargs)
       t._referred_modalities = value.referred_modalities
       return t
-    if isinstance(value, Template):
-      lfun = cls(template_str=value.template_str, **kwargs)  # pylint: disable=attribute-error
-      # So lfun could acccess all attributes from value.
-      lfun.sym_setparent(value)
-      return lfun
     return cls(template_str='{{input}}', input=value, **kwargs)
 
   def _html_tree_view_content(

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun/core/template_test.py

@@ -198,6 +198,24 @@ class FromValueTest(unittest.TestCase):
     )
     self.assertEqual(message.metadata, m.metadata)
 
+  def test_from_message_convertible(self):
+
+    class MyFormat(pg.Object):
+      text: str
+
+    class MyConverter(message_lib.MessageConverter):  # pylint: disable=unused-variable
+      FORMAT_ID = 'int'
+      OUTPUT_TYPE = MyFormat
+
+      def to_value(self, m: message_lib.Message) -> MyFormat:
+        return MyFormat(text=m.text)
+
+      def from_value(self, value: MyFormat) -> message_lib.Message:
+        return message_lib.UserMessage(value.text)
+
+    t = Template.from_value(MyFormat(text='1'))
+    self.assertEqual(t.render(), '1')
+
   def test_from_same_template(self):
     t = Template('Hello {{x}}', x=1)
     t2 = Template.from_value(t)

{langfun-0.1.2.dev202511030805 → langfun-0.1.2.dev202511040805}/langfun.egg-info/PKG-INFO

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