langfun 0.1.2.dev202410100804__py3-none-any.whl → 0.1.2.dev202410120803__py3-none-any.whl

langfun/core/modalities/mime.py

@@ -178,14 +178,50 @@ class Mime(lf.Modality):
       assert content is not None
       return content
 
-  def _repr_html_(self) -> str:
+  def _html_tree_view_content(
+      self,
+      **kwargs) -> str:
+    return self._raw_html()
+
+  def _html_tree_view_render(
+      self,
+      view: pg.views.HtmlTreeView,
+      raw_mime_content: bool = pg.View.PresetArgValue(False),                 # pytype: disable=annotation-type-mismatch
+      display_modality_when_hover: bool = pg.View.PresetArgValue(False),   # pytype: disable=annotation-type-mismatch
+      **kwargs
+  ):
+    if raw_mime_content:
+      return pg.Html(self._raw_html())
+    else:
+      if display_modality_when_hover:
+        kwargs.update(
+            display_modality_when_hover=True,
+            enable_summary_tooltip=True,
+        )
+      return super()._html_tree_view_render(view=view, **kwargs)
+
+  def _html_tree_view_tooltip(
+      self,
+      *,
+      view: pg.views.HtmlTreeView,
+      content: pg.Html | str | None = None,
+      display_modality_when_hover: bool = pg.View.PresetArgValue(False),    # pytype: disable=annotation-type-mismatch
+      **kwargs
+  ):
+    if content is None and display_modality_when_hover:
+      content = self._raw_html()
+    return super()._html_tree_view_tooltip(
+        view=view, content=content, **kwargs
+    )
+
+  def _raw_html(self) -> str:
     if self.uri and self.uri.lower().startswith(('http:', 'https:', 'ftp:')):
       uri = self.uri
     else:
       uri = self.content_uri
-    return self._html(uri)
+    return self._mime_control_for(uri)
 
-  def _html(self, uri) -> str:
+  def _mime_control_for(self, uri) -> str:
     return f'<embed type="{self.mime_type}" src="{uri}"/>'
 
 

langfun/core/modalities/mime_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """MIME tests."""
+import inspect
 import unittest
 from unittest import mock
 
@@ -77,6 +78,44 @@ class CustomMimeTest(unittest.TestCase):
       self.assertEqual(content.to_bytes(), 'bar')
       self.assertEqual(content.mime_type, 'text/plain')
 
+  def assert_html_content(self, html, expected):
+    expected = inspect.cleandoc(expected).strip()
+    actual = html.content.strip()
+    if actual != expected:
+      print(actual)
+    self.assertEqual(actual, expected)
+
+  def test_html(self):
+    self.assert_html_content(
+        mime.Custom('text/plain', b'foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+        ),
+        """
+        <details open class="pyglove custom"><summary><div class="summary_title">Custom(...)</div></summary><embed type="text/plain" src="data:text/plain;base64,Zm9v"/></details>
+        """
+    )
+    self.assert_html_content(
+        mime.Custom('text/plain', b'foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            raw_mime_content=True,
+        ),
+        """
+        <embed type="text/plain" src="data:text/plain;base64,Zm9v"/>
+        """
+    )
+    self.assert_html_content(
+        mime.Custom('text/plain', b'foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            display_modality_when_hover=True,
+        ),
+        """
+        <details open class="pyglove custom"><summary><div class="summary_title">Custom(...)</div><span class="tooltip custom"><embed type="text/plain" src="data:text/plain;base64,Zm9v"/></span></summary><embed type="text/plain" src="data:text/plain;base64,Zm9v"/></details>
+        """
+    )
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/modalities/ms_office.py

@@ -29,7 +29,7 @@ class Xlsx(mime.Mime):
       'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
   )
 
-  def to_html(self) -> str:
+  def _raw_html(self) -> str:
     try:
       import pandas as pd  # pylint: disable=g-import-not-at-top
       import openpyxl      # pylint: disable=g-import-not-at-top, unused-import
@@ -40,9 +40,6 @@ class Xlsx(mime.Mime):
           'Please install "langfun[mime-xlsx]" to enable XLSX support.'
       ) from e
 
-  def _repr_html_(self) -> str:
-    return self.to_html()
-
   def _is_compatible(self, mime_types: Iterable[str]) -> bool:
     return bool(set(mime_types).intersection([
         'text/html',
@@ -52,7 +49,7 @@ class Xlsx(mime.Mime):
   def _make_compatible(self, mime_types: Iterable[str]) -> mime.Mime:
     """Returns the MimeType of the converted file."""
     del mime_types
-    return mime.Mime(uri=self.uri, content=self.to_html())
+    return mime.Mime(uri=self.uri, content=self._raw_html())
 
 
 class Docx(mime.Mime):

langfun/core/modalities/ms_office_test.py

@@ -347,7 +347,7 @@ class XlsxTest(unittest.TestCase):
           ),
       )
       self.assertEqual(content.to_bytes(), xlsx_bytes)
-      self.assertEqual(content.to_html(), expected_xlsx_html)
+      self.assertEqual(content._raw_html(), expected_xlsx_html)
 
 
 class PptxTest(unittest.TestCase):

langfun/core/modalities/pdf_test.py

@@ -49,7 +49,7 @@ class PdfTest(unittest.TestCase):
     pdf = pdf_lib.PDF.from_bytes(pdf_bytes)
     self.assertIn(
         '<embed type="application/pdf" src="data:application/pdf;base64,',
-        pdf._repr_html_()
+        pdf._raw_html()
     )
 
 

langfun/core/modalities/video.py

@@ -26,5 +26,5 @@ class Video(mime.Mime):
   def video_format(self) -> str:
     return self.mime_type.removeprefix(self.MIME_PREFIX + '/')
 
-  def _html(self, uri: str) -> str:
+  def _mime_control_for(self, uri: str) -> str:
     return f'<video controls> <source src="{uri}"> </video>'

langfun/core/modalities/video_test.py

@@ -38,7 +38,7 @@ class VideoContentTest(unittest.TestCase):
     video = video_lib.Video.from_bytes(mp4_bytes)
     self.assertEqual(video.mime_type, 'video/mp4')
     self.assertEqual(video.video_format, 'mp4')
-    self.assertIn('data:video/mp4;base64,', video._repr_html_())
+    self.assertIn('data:video/mp4;base64,', video._raw_html())
     self.assertEqual(video.to_bytes(), mp4_bytes)
 
   def test_bad_video(self):
@@ -56,7 +56,7 @@ class VideoFileTest(unittest.TestCase):
       self.assertEqual(video.video_format, 'mp4')
       self.assertEqual(video.mime_type, 'video/mp4')
       self.assertEqual(
-          video._repr_html_(),
+          video._raw_html(),
           '<video controls> <source src="http://mock/web/a.mp4"> </video>',
       )
       self.assertEqual(video.to_bytes(), mp4_bytes)

langfun/core/structured/completion_test.py

@@ -581,6 +581,7 @@ class CompleteStructureTest(unittest.TestCase):
             text='Activity(description="foo")',
             result=Activity(description='foo'),
             score=1.0,
+            is_cached=False,
             logprobs=None,
             usage=lf.LMSamplingUsage(553, 27, 580),
             tags=['lm-response', 'lm-output', 'transformed']

langfun/core/structured/mapping.py

@@ -183,6 +183,44 @@ class MappingExample(lf.NaturalLanguageFormattable, lf.Component):
       result.write(lf.colored(str(self.metadata), color='cyan'))
     return result.getvalue().strip()
 
+  def _html_tree_view_content(
+      self,
+      *,
+      parent: Any,
+      view: pg.views.HtmlTreeView,
+      root_path: pg.KeyPath,
+      **kwargs,
+  ):
+    def render_value(value, **kwargs):
+      if isinstance(value, lf.Template):
+        # Make a shallow copy to make sure modalities are rooted by
+        # the input.
+        value = value.clone().render()
+      return view.render(value, **kwargs)
+
+    exclude_keys = []
+    if not self.context:
+      exclude_keys.append('context')
+    if not self.schema:
+      exclude_keys.append('schema')
+    if not self.metadata:
+      exclude_keys.append('metadata')
+
+    kwargs.pop('special_keys', None)
+    kwargs.pop('exclude_keys', None)
+    return view.complex_value(
+        self.sym_init_args,
+        parent=self,
+        root_path=root_path,
+        render_value_fn=render_value,
+        special_keys=['input', 'output', 'context', 'schema', 'metadata'],
+        exclude_keys=exclude_keys,
+        **kwargs
+    )
+
+  def _html_tree_view_uncollapse_level(self) -> int:
+    return 2
+
 
 class Mapping(lf.LangFunc):
   """Base class for mapping.

langfun/core/structured/mapping_test.py

@@ -14,6 +14,7 @@
 """Tests for structured mapping example."""
 
 import inspect
+from typing import Any
 import unittest
 
 import langfun.core as lf
@@ -164,6 +165,60 @@ class MappingExampleTest(unittest.TestCase):
         pg.eq(pg.from_json_str(example.to_json_str()), example)
     )
 
+  def assert_html_content(self, html, expected):
+    expected = inspect.cleandoc(expected).strip()
+    actual = html.content.strip()
+    if actual != expected:
+      print(actual)
+    self.assertEqual(actual, expected)
+
+  def test_html(self):
+
+    class Answer(pg.Object):
+      answer: int
+
+    class Addition(lf.Template):
+      """Template Addition.
+
+      {{x}} + {{y}} = ?
+      """
+      x: Any
+      y: Any
+
+    example = mapping.MappingExample(
+        input=Addition(x=1, y=2),
+        schema=Answer,
+        context='compute 1 + 1',
+        output=Answer(answer=3),
+        metadata={'foo': 'bar'},
+    )
+    self.assert_html_content(
+        example.to_html(
+            enable_summary_tooltip=False, include_message_metadata=False
+        ),
+        """
+        <details open class="pyglove mapping-example"><summary><div class="summary_title">MappingExample(...)</div></summary><div class="complex_value mapping-example"><div class="special_value"><details open class="pyglove user-message lf-message"><summary><div class="summary_name">input</div><div class="summary_title">UserMessage(...)</div></summary><div class="complex_value"><div class="message-tags"><span>rendered</span></div><div class="message-text">1 + 2 = ?</div></div></details></div><div class="special_value"><details open class="pyglove answer"><summary><div class="summary_name">output</div><div class="summary_title">Answer(...)</div></summary><div class="complex_value answer"><table><tr><td><span class="object_key str">answer</span><span class="tooltip key-path">output.answer</span></td><td><div><span class="simple_value int">3</span></div></td></tr></table></div></details></div><div class="special_value"><details open class="pyglove str"><summary><div class="summary_name">context</div><div class="summary_title">&#x27;compute 1 + 1&#x27;</div></summary><span class="simple_value str">&#x27;compute 1 + 1&#x27;</span></details></div><div class="special_value"><details open class="pyglove schema"><summary><div class="summary_name">schema</div><div class="summary_title">Schema(...)</div></summary><div class="lf-schema-definition">Answer
+
+        ```python
+        class Answer:
+          answer: int
+        ```</div></details></div><div class="special_value"><details open class="pyglove dict"><summary><div class="summary_name">metadata</div><div class="summary_title">Dict(...)</div></summary><div class="complex_value dict"><table><tr><td><span class="object_key str">foo</span><span class="tooltip key-path">metadata.foo</span></td><td><div><span class="simple_value str">&#x27;bar&#x27;</span></div></td></tr></table></div></details></div></div></details>
+        """
+    )
+
+    example = mapping.MappingExample(
+        input=Addition(x=1, y=2),
+        output=Answer(answer=3),
+    )
+    self.assert_html_content(
+        example.to_html(
+            enable_summary_tooltip=False, include_message_metadata=False
+        ),
+        """
+        <details open class="pyglove mapping-example"><summary><div class="summary_title">MappingExample(...)</div></summary><div class="complex_value mapping-example"><div class="special_value"><details open class="pyglove user-message lf-message"><summary><div class="summary_name">input</div><div class="summary_title">UserMessage(...)</div></summary><div class="complex_value"><div class="message-tags"><span>rendered</span></div><div class="message-text">1 + 2 = ?</div></div></details></div><div class="special_value"><details open class="pyglove answer"><summary><div class="summary_name">output</div><div class="summary_title">Answer(...)</div></summary><div class="complex_value answer"><table><tr><td><span class="object_key str">answer</span><span class="tooltip key-path">output.answer</span></td><td><div><span class="simple_value int">3</span></div></td></tr></table></div></details></div></div></details>
+        """
+    )
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/structured/parsing_test.py

@@ -285,7 +285,7 @@ class ParseStructurePythonTest(unittest.TestCase):
     self.assertEqual(
         r,
         lf.AIMessage(
-            '1', score=1.0, result=1, logprobs=None,
+            '1', score=1.0, result=1, logprobs=None, is_cached=False,
             usage=lf.LMSamplingUsage(652, 1, 653),
             tags=['lm-response', 'lm-output', 'transformed']
         ),
@@ -645,6 +645,7 @@ class CallTest(unittest.TestCase):
             result=3,
             score=1.0,
             logprobs=None,
+            is_cached=False,
             usage=lf.LMSamplingUsage(315, 1, 316),
             tags=['lm-response', 'lm-output', 'transformed']
         ),

langfun/core/structured/prompting_test.py

@@ -82,6 +82,7 @@ class QueryTest(unittest.TestCase):
             result=1,
             score=1.0,
             logprobs=None,
+            is_cached=False,
             usage=lf.LMSamplingUsage(323, 1, 324),
             tags=['lm-response', 'lm-output', 'transformed'],
         ),

langfun/core/structured/schema.py

@@ -189,6 +189,40 @@ class Schema(lf.NaturalLanguageFormattable, pg.Object):
       return value
     return cls(parse_value_spec(value))
 
+  def _html_tree_view_content(
+      self,
+      *,
+      view: pg.views.HtmlTreeView,
+      root_path: pg.KeyPath,
+      **kwargs,
+  ):
+    return pg.Html.element(
+        'div',
+        [self.schema_str(protocol='python')],
+        css_class=['lf-schema-definition']
+    ).add_style(
+        """
+        .lf-schema-definition {
+            color: blue;
+            margin: 5px;
+            white-space: pre-wrap;
+        }
+        """
+    )
+
+  def _html_tree_view_tooltip(
+      self,
+      *,
+      view: pg.views.HtmlTreeView,
+      content: pg.Html | str | None = None,
+      **kwargs,
+  ):
+    return view.tooltip(
+        self,
+        content=content or pg.Html.escape(self.schema_str(protocol='python')),
+        **kwargs
+    )
+
 
 def _top_level_object_specs_from_value(value: pg.Symbolic) -> list[Type[Any]]:
   """Returns a list of top level value specs from a symbolic value."""

langfun/core/template.py

@@ -17,7 +17,7 @@ import contextlib
 import dataclasses
 import functools
 import inspect
-from typing import Annotated, Any, Callable, Iterator, Set, Tuple, Type, Union
+from typing import Annotated, Any, Callable, Iterator, Sequence, Set, Tuple, Type, Union
 
 import jinja2
 from jinja2 import meta as jinja2_meta
@@ -526,6 +526,115 @@ class Template(
       return lfun
     return cls(template_str='{{input}}', input=value, **kwargs)
 
+  def _html_tree_view_content(
+      self,
+      *,
+      view: pg.views.HtmlTreeView,
+      root_path: pg.KeyPath,
+      collapse_template_vars_level: int | None = pg.View.PresetArgValue(1),
+      collapse_level: int | None = pg.View.PresetArgValue(1),  # pytype: disable=annotation-type-mismatch
+      **kwargs,
+  ):
+    def render_template_str():
+      return pg.Html.element(
+          'div',
+          [
+              pg.Html.element('span', [self.template_str])
+          ],
+          css_class=['template-str'],
+      )
+
+    def render_fields():
+      def render_value_fn(value, *, root_path, **kwargs):
+        if isinstance(value, component.ContextualAttribute):
+          inferred = self.sym_inferred(root_path.key, pg.MISSING_VALUE)
+          if inferred != pg.MISSING_VALUE:
+            return pg.Html.element(
+                'div',
+                [
+                    view.render(inferred, root_path=root_path, **kwargs)
+                ],
+                css_class=['inferred-value'],
+            )
+          else:
+            return pg.Html.element(
+                'span',
+                ['(external)'],
+                css_class=['contextual-variable'],
+            )
+        return view.render(
+            value, root_path=root_path, **kwargs
+        )
+      return pg.Html.element(
+          'fieldset',
+          [
+              pg.Html.element('legend', ['Template Variables']),
+              view.complex_value(
+                  self.sym_init_args,
+                  name='fields',
+                  root_path=root_path,
+                  render_value_fn=render_value_fn,
+                  exclude_keys=['template_str', 'clean'],
+                  parent=self,
+                  collapse_level=view.max_collapse_level(
+                      collapse_level,
+                      collapse_template_vars_level,
+                      root_path
+                  ),
+              ),
+          ],
+          css_class=['template-fields'],
+      )
+
+    return pg.Html.element(
+        'div',
+        [
+            render_template_str(),
+            render_fields(),
+        ],
+        css_class=['complex_value'],
+    )
+
+  def _html_style(self) -> list[str]:
+    return super()._html_style() + [
+        """
+        /* Langfun Template styles. */
+        .template-str {
+            padding: 10px;
+            margin: 10px 5px 10px 5px;
+            font-style: italic;
+            font-size: 1.1em;
+            white-space: pre-wrap;
+            border: 1px solid #EEE;
+            border-radius: 5px;
+            background-color: #EEE;
+            color: #cc2986;
+        }
+        .template-fields {
+            margin: 0px 0px 5px 0px;
+            border: 1px solid #EEE;
+            padding: 5px;
+        }
+        .template-fields > legend {
+            font-size: 0.8em;
+            margin: 5px 0px 5px 0px;
+        }
+        .inferred-value::after {
+            content: ' (inferred)';
+            color: gray;
+            font-style: italic;
+        }
+        .contextual-variable {
+            margin: 0px 0px 0px 5px;
+            font-style: italic;
+            color: gray;
+        }
+        """
+    ]
+
+  # Additional CSS class to add to the root <details> element.
+  def _html_element_class(self) -> Sequence[str] | None:
+    return super()._html_element_class() + ['lf-template']
 
 # Register converter from str to LangFunc, therefore we can always
 # pass strs to attributes that accept LangFunc.

langfun/core/template_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Template test."""
 import inspect
+from typing import Any
 import unittest
 
 from langfun.core import component
@@ -552,5 +553,41 @@ class TemplateRenderEventTest(unittest.TestCase):
     self.assertEqual(render_stacks, [[l]])
 
 
+class HtmlTest(unittest.TestCase):
+
+  def assert_html_content(self, html, expected):
+    expected = inspect.cleandoc(expected).strip()
+    actual = html.content.strip()
+    if actual != expected:
+      print(actual)
+    self.assertEqual(actual, expected)
+
+  def test_html(self):
+
+    class Foo(Template):
+      """Template Foo.
+
+      {{x}} + {{y}} = ?
+      """
+      x: Any
+      y: Any
+
+    class Bar(Template):
+      """Template Bar.
+
+      {{y}} + {{z}}
+      """
+      y: Any
+
+    self.assert_html_content(
+        Foo(x=Bar('{{y}} + {{z}}'), y=1).to_html(
+            enable_summary_tooltip=False,
+        ),
+        """
+        <details open class="pyglove foo lf-template"><summary><div class="summary_title">Foo(...)</div></summary><div class="complex_value"><div class="template-str"><span>{{x}} + {{y}} = ?</span></div><fieldset class="template-fields"><legend>Template Variables</legend><div class="complex_value foo lf-template"><table><tr><td><span class="object_key str">x</span><span class="tooltip key-path">x</span></td><td><div><details class="pyglove bar lf-template"><summary><div class="summary_title">Bar(...)</div></summary><div class="complex_value"><div class="template-str"><span>{{y}} + {{z}}</span></div><fieldset class="template-fields"><legend>Template Variables</legend><div class="complex_value bar lf-template"><table><tr><td><span class="object_key str">y</span><span class="tooltip key-path">x.y</span></td><td><div><div class="inferred-value"><span class="simple_value int">1</span></div></div></td></tr><tr><td><span class="object_key str">z</span><span class="tooltip key-path">x.z</span></td><td><div><span class="contextual-variable">(external)</span></div></td></tr></table></div></fieldset></div></details></div></td></tr><tr><td><span class="object_key str">y</span><span class="tooltip key-path">y</span></td><td><div><span class="simple_value int">1</span></div></td></tr></table></div></fieldset></div></details>
+        """
+    )
+
+
 if __name__ == '__main__':
   unittest.main()

langfun/core/templates/selfplay_test.py

@@ -59,7 +59,8 @@ class SelfPlayTest(unittest.TestCase):
       self.assertEqual(
           g(),
           lf.AIMessage(
-              '10', score=0.0, logprobs=None, usage=lf.UsageNotAvailable()
+              '10', score=0.0, logprobs=None, is_cached=False,
+              usage=lf.UsageNotAvailable()
           )
       )
 
@@ -72,7 +73,8 @@ class SelfPlayTest(unittest.TestCase):
       self.assertEqual(
           g(),
           lf.AIMessage(
-              '2', score=0.0, logprobs=None, usage=lf.UsageNotAvailable()
+              '2', score=0.0, logprobs=None, is_cached=False,
+              usage=lf.UsageNotAvailable()
           )
       )
 

{langfun-0.1.2.dev202410100804.dist-info → langfun-0.1.2.dev202410120803.dist-info}/METADATA

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