langfun 0.1.2.dev202410170804__py3-none-any.whl → 0.1.2.dev202410190803__py3-none-any.whl

langfun/core/component.py

@@ -286,6 +286,54 @@ class ContextualAttribute(pg.symbolic.ValueFromParentChain):
     else:
       return pg.MISSING_VALUE
 
+  def _html_tree_view_content(
+      self,
+      *,
+      view: pg.views.HtmlTreeView,
+      parent: Any,
+      root_path: pg.KeyPath,
+      **kwargs,
+  ) -> pg.Html:
+    inferred_value = pg.MISSING_VALUE
+    if isinstance(parent, pg.Symbolic) and root_path:
+      inferred_value = parent.sym_inferred(root_path.key, pg.MISSING_VALUE)
+
+    if inferred_value is not pg.MISSING_VALUE:
+      kwargs.pop('name', None)
+      return view.render(
+          inferred_value, parent=self, root_path=root_path + '<inferred>',
+          **view.get_passthrough_kwargs(**kwargs)
+      )
+    return pg.Html.element(
+        'div',
+        [
+            '(not available)',
+        ],
+        css_classes=['unavailable-contextual'],
+    )
+
+  def _html_tree_view_config(self) -> dict[str, Any]:
+    return pg.views.HtmlTreeView.get_kwargs(
+        super()._html_tree_view_config(),
+        dict(
+            collapse_level=1,
+        )
+    )
+
+  @classmethod
+  def _html_tree_view_css_styles(cls) -> list[str]:
+    return super()._html_tree_view_css_styles() + [
+        """
+        .contextual-attribute {
+          color: purple;
+        }
+        .unavailable-contextual {
+          color: gray;
+          font-style: italic;
+        }
+        """
+    ]
+
 
 # NOTE(daiyip): Returning Any instead of `lf.ContextualAttribute` to avoid
 # pytype check error as `contextual()` can be assigned to any type.

langfun/core/component_test.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """Contextual component and app test."""
 
+import inspect
+from typing import Any
 import unittest
 import weakref
 
@@ -297,6 +299,52 @@ class ContextualAttributeTest(unittest.TestCase):
     self.assertEqual(c.z, 3)
     self.assertEqual(b.z, 3)
 
+  def test_to_html(self):
+    class A(lf.Component):
+      x: int = 1
+      y: int = lf.contextual()
+
+    def assert_content(html, expected):
+      expected = inspect.cleandoc(expected).strip()
+      actual = html.content.strip()
+      if actual != expected:
+        print(actual)
+      self.assertEqual(actual.strip(), expected)
+
+    self.assertIn(
+        inspect.cleandoc(
+            """
+            .contextual-attribute {
+              color: purple;
+            }
+            .unavailable-contextual {
+              color: gray;
+              font-style: italic;
+            }
+            """
+        ),
+        A().to_html().style_section,
+    )
+
+    assert_content(
+        A().to_html(enable_summary_tooltip=False),
+        """
+        <details open class="pyglove a"><summary><div class="summary-title">A(...)</div></summary><div class="complex-value a"><details open class="pyglove int"><summary><div class="summary-name">x<span class="tooltip">x</span></div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details><details open class="pyglove contextual-attribute"><summary><div class="summary-name">y<span class="tooltip">y</span></div><div class="summary-title">ContextualAttribute(...)</div></summary><div class="unavailable-contextual">(not available)</div></details></div></details>
+        """
+    )
+
+    class B(lf.Component):
+      z: Any
+      y: int = 2
+
+    b = B(A())
+    assert_content(
+        b.z.to_html(enable_summary_tooltip=False),
+        """
+        <details open class="pyglove a"><summary><div class="summary-title">A(...)</div></summary><div class="complex-value a"><details open class="pyglove int"><summary><div class="summary-name">x<span class="tooltip">x</span></div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details><details open class="pyglove contextual-attribute"><summary><div class="summary-name">y<span class="tooltip">y</span></div><div class="summary-title">ContextualAttribute(...)</div></summary><span class="simple-value int">2</span></details></div></details>
+        """
+    )
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/concurrent.py

@@ -921,5 +921,11 @@ def _progress_control(
     raise ValueError(f'Unsupported progress bar type: {progress_bar}')
 
 
+def get_executor(
+    resource_id: str,
+    max_workers: int | None = None) -> concurrent.futures.ThreadPoolExecutor:
+  """Gets a thread pool executor associated with a resource id."""
+  return _executor_pool.get(resource_id, max_workers)
+
 # The global executor pool based on resource IDs.
 _executor_pool = ExecutorPool()

langfun/core/eval/base.py

@@ -1087,7 +1087,7 @@ class Evaluation(Evaluable):
       )
       error = e
 
-    copy.audit(example, output_message, error, dryrun=True)
+    copy.audit(1, example, output_message, error, dryrun=True)
     result = copy.finalize()
 
     if verbose:
@@ -1124,19 +1124,20 @@ class Evaluation(Evaluable):
     with lf.use_settings(debug=debug, cache=self.cache):
       self._reset()
 
-      def _process(example: Any):
+      def _process(idx_and_example: Any):
         # NOTE(daiyip): set the `input` symbol of the globals to None, so LLM
         # generated code with calls to `input` will raise an error, thus not
         # blocking the evaluation.
+        _, example = idx_and_example
         with lf_coding.context(input=None):
           output_message = self.process(example, **(self.additional_args or {}))
           self.process_output(example, output_message)
           return output_message
 
       try:
-        for example, message, error in lf.concurrent_map(
+        for (idx, example), message, error in lf.concurrent_map(
             _process,
-            examples,
+            enumerate(examples),
             max_workers=self.max_workers,
             show_progress=progress_bar or False,
             status_fn=self._status,
@@ -1148,7 +1149,7 @@ class Evaluation(Evaluable):
                 if isinstance(error, lf_structured.MappingError)
                 else None
             )
-          self.audit(example, message, error)
+          self.audit(idx + 1, example, message, error)
       finally:
         # Save cache upon completion or interruption.
         if self.dir and self.cache:
@@ -1437,6 +1438,7 @@ class Evaluation(Evaluable):
 
   def audit(
       self,
+      example_idx: int,
       example: Any,
       message: lf.Message | None,
       error: Exception | None = None,
@@ -1445,6 +1447,7 @@ class Evaluation(Evaluable):
     """Audits the example against the output. Subclasses should override.
 
     Args:
+      example_idx: 1-based index of the example in its dataset.
       example: The input object.
       message: The entire message returned by the LM, which could be used to
         trace the LM input, response and parsed structure. If error is raised
@@ -1465,7 +1468,7 @@ class Evaluation(Evaluable):
     else:
       assert message is not None
       output = message.text if self.schema is None else message.result
-      self.audit_processed(example, output, message, dryrun=dryrun)
+      self.audit_processed(example_idx, example, output, message, dryrun=dryrun)
 
     # Audit usage.
     if message is not None:
@@ -1482,7 +1485,8 @@ class Evaluation(Evaluable):
         self._num_usages += 1
 
   def audit_processed(
-      self, example: Any, output: Any, message: lf.Message, dryrun: bool = False
+      self, example_idx: int, example: Any, output: Any, message: lf.Message,
+      dryrun: bool = False
   ) -> None:
     """Audits a successfully processed example. Subclass should override."""
 

langfun/core/eval/matching.py

@@ -41,8 +41,8 @@ class Matching(base.Evaluation):
     """Returns the answer from the structure output."""
 
   @property
-  def matches(self) -> list[tuple[Any, Any, lf.Message]]:
-    """Returns the matches examples, outputs and the output messages."""
+  def matches(self) -> list[tuple[int, Any, Any, lf.Message]]:
+    """Returns the matches IDs, examples, outputs and the output messages."""
     return self._matches
 
   @property
@@ -57,7 +57,7 @@ class Matching(base.Evaluation):
     return self.num_matches / self.num_completed
 
   @property
-  def mismatches(self) -> list[tuple[Any, Any, lf.Message]]:
+  def mismatches(self) -> list[tuple[int, Any, Any, lf.Message]]:
     """Returns the mismatches examples, outputs and output messages."""
     return self._mismatches
 
@@ -87,7 +87,8 @@ class Matching(base.Evaluation):
     self._mismatches = []
 
   def audit_processed(
-      self, example: Any, output: Any, message: lf.Message, dryrun: bool = False
+      self, example_idx: int, example: Any, output: Any, message: lf.Message,
+      dryrun: bool = False
   ) -> None:
     groundtruth = self.groundtruth(example)
     answer = self.answer(output, example)
@@ -107,9 +108,9 @@ class Matching(base.Evaluation):
       )
 
     if self.match(answer, groundtruth):
-      self._matches.append((example, output, message))
+      self._matches.append((example_idx, example, output, message))
     else:
-      self._mismatches.append((example, output, message))
+      self._mismatches.append((example_idx, example, output, message))
 
   def match(self, answer: Any, groundtruth: Any) -> bool:
     """Matches answer against the groundtruth. Subclasses can override."""
@@ -247,7 +248,7 @@ class Matching(base.Evaluation):
       # Fall back to the default format.
       return None
 
-    for i, (example, output, message) in enumerate(self.matches):
+    for i, (_, example, output, message) in enumerate(self.matches):
       bgcolor = 'white' if i % 2 == 0 else '#DDDDDD'
       s.write(f'<tr style="background-color: {bgcolor}"><td>{i + 1}</td>')
       input_str = lf.repr_utils.escape_quoted(
@@ -282,7 +283,7 @@ class Matching(base.Evaluation):
         '</tr>'
     )
 
-    for i, (example, output, message) in enumerate(self.mismatches):
+    for i, (_, example, output, message) in enumerate(self.mismatches):
       bgcolor = 'white' if i % 2 == 0 else '#DDDDDD'
       s.write(f'<tr style="background-color: {bgcolor}"><td>{i + 1}</td>')
       input_str = pg.format(example, verbose=False, max_bytes_len=32)

langfun/core/eval/scoring.py

@@ -62,8 +62,10 @@ class Scoring(base.Evaluation):
     self._scored = []
 
   def audit_processed(
-      self, example: Any, output: Any, message: lf.Message, dryrun: bool = False
+      self, example_idx: int, example: Any, output: Any, message: lf.Message,
+      dryrun: bool = False
   ) -> None:
+    del example_idx
     score = self.score(example, output)
 
     if dryrun:

langfun/core/logging.py

@@ -15,8 +15,9 @@
 
 import contextlib
 import datetime
+import functools
 import typing
-from typing import Any, Iterator, Literal, Sequence
+from typing import Any, Iterator, Literal
 
 from langfun.core import component
 from langfun.core import console
@@ -57,11 +58,11 @@ class LogEntry(pg.Object):
       self,
       view: pg.views.HtmlTreeView,
       title: str | pg.Html | None = None,
-      max_str_len_for_summary: int = pg.View.PresetArgValue(80),  # pytype: disable=annotation-type-mismatch
+      max_summary_len_for_str: int = 80,
       **kwargs
       ) -> str:
-    if len(self.message) > max_str_len_for_summary:
-      message = self.message[:max_str_len_for_summary] + '...'
+    if len(self.message) > max_summary_len_for_str:
+      message = self.message[:max_summary_len_for_str] + '...'
     else:
       message = self.message
 
@@ -69,18 +70,18 @@ class LogEntry(pg.Object):
         pg.Html.element(
             'span',
             [self.time.strftime('%H:%M:%S')],
-            css_class=['log-time']
+            css_classes=['log-time']
         ),
         pg.Html.element(
             'span',
             [pg.Html.escape(message)],
-            css_class=['log-summary'],
+            css_classes=['log-summary'],
         ),
     )
     return view.summary(
         self,
         title=title or s,
-        max_str_len_for_summary=max_str_len_for_summary,
+        max_summary_len_for_str=max_summary_len_for_str,
         **kwargs,
     )
 
@@ -89,43 +90,45 @@ class LogEntry(pg.Object):
       self,
       view: pg.views.HtmlTreeView,
       root_path: pg.KeyPath,
-      collapse_log_metadata_level: int | None = pg.View.PresetArgValue(0),
-      max_str_len_for_summary: int = pg.View.PresetArgValue(80),
-      collapse_level: int | None = pg.View.PresetArgValue(1),
+      max_summary_len_for_str: int = 80,
+      collapse_level: int | None = 1,
+      extra_flags: dict[str, Any] | None = None,
       **kwargs
   ) -> pg.Html:
     # pytype: enable=annotation-type-mismatch
+    extra_flags = extra_flags if extra_flags is not None else {}
+    collapse_log_metadata_level: int | None = extra_flags.get(
+        'collapse_log_metadata_level', None
+    )
     def render_message_text():
-      if len(self.message) < max_str_len_for_summary:
+      if len(self.message) < max_summary_len_for_str:
         return None
       return pg.Html.element(
           'span',
           [pg.Html.escape(self.message)],
-          css_class=['log-text'],
+          css_classes=['log-text'],
       )
 
     def render_metadata():
       if not self.metadata:
         return None
-      child_path = root_path + 'metadata'
       return pg.Html.element(
           'div',
           [
               view.render(
                   self.metadata,
                   name='metadata',
-                  root_path=child_path,
+                  root_path=root_path + 'metadata',
                   parent=self,
-                  collapse_level=(
-                      view.max_collapse_level(
-                          collapse_level,
-                          collapse_log_metadata_level,
-                          child_path
-                      )
-                  )
+                  collapse_level=view.get_collapse_level(
+                      (collapse_level, -1), collapse_log_metadata_level,
+                  ),
+                  max_summary_len_for_str=max_summary_len_for_str,
+                  extra_flags=extra_flags,
+                  **view.get_passthrough_kwargs(**kwargs),
               )
           ],
-          css_class=['log-metadata'],
+          css_classes=['log-metadata'],
       )
 
     return pg.Html.element(
@@ -134,12 +137,23 @@ class LogEntry(pg.Object):
             render_message_text(),
             render_metadata(),
         ],
-        css_class=['complex_value'],
+        css_classes=['complex_value'],
+    )
+
+  def _html_tree_view_config(self) -> dict[str, Any]:
+    return pg.views.HtmlTreeView.get_kwargs(
+        super()._html_tree_view_config(),
+        dict(
+            css_classes=[f'log-{self.level}'],
+        )
     )
 
-  def _html_style(self) -> list[str]:
-    return super()._html_style() + [
+  @classmethod
+  @functools.cache
+  def _html_tree_view_css_styles(cls) -> list[str]:
+    return super()._html_tree_view_css_styles() + [
         """
+        /* Langfun LogEntry styles. */
         .log-time {
           color: #222;
           font-size: 12px;
@@ -203,9 +217,6 @@ class LogEntry(pg.Object):
         """
     ]
 
-  def _html_element_class(self) -> Sequence[str] | None:
-    return super()._html_element_class() + [f'log-{self.level}']
-
 
 def log(level: LogLevel,
         message: str,

langfun/core/logging_test.py

@@ -69,20 +69,36 @@ class LoggingTest(unittest.TestCase):
             time=time, metadata={}
         ).to_html(enable_summary_tooltip=False),
         """
-        <details open class="pyglove log-entry log-info"><summary><div class="summary_title"><span class="log-time">12:30:45</span><span class="log-summary">5 + 2 &gt; 3</span></div></summary><div class="complex_value"></div></details>
+        <details open class="pyglove log-entry log-info"><summary><div class="summary-title log-info"><span class="log-time">12:30:45</span><span class="log-summary">5 + 2 &gt; 3</span></div></summary><div class="complex_value"></div></details>
         """
     )
     self.assert_html_content(
         logging.LogEntry(
             level='error', message='This is a longer message: 5 + 2 > 3',
-            time=time, metadata=dict(x=1, y=2)
+            time=time, metadata=dict(x=dict(z=1), y=2)
         ).to_html(
-            max_str_len_for_summary=10,
+            extra_flags=dict(
+                collapse_log_metadata_level=1,
+            ),
+            max_summary_len_for_str=10,
             enable_summary_tooltip=False,
-            collapse_log_metadata_level=1
         ),
         """
-        <details open class="pyglove log-entry log-error"><summary><div class="summary_title"><span class="log-time">12:30:45</span><span class="log-summary">This is a ...</span></div></summary><div class="complex_value"><span class="log-text">This is a longer message: 5 + 2 &gt; 3</span><div class="log-metadata"><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">x</span><span class="tooltip key-path">metadata.x</span></td><td><div><span class="simple_value int">1</span></div></td></tr><tr><td><span class="object_key str">y</span><span class="tooltip key-path">metadata.y</span></td><td><div><span class="simple_value int">2</span></div></td></tr></table></div></details></div></div></details>
+        <details open class="pyglove log-entry log-error"><summary><div class="summary-title log-error"><span class="log-time">12:30:45</span><span class="log-summary">This is a ...</span></div></summary><div class="complex_value"><span class="log-text">This is a longer message: 5 + 2 &gt; 3</span><div class="log-metadata"><details open class="pyglove dict"><summary><div class="summary-name">metadata<span class="tooltip">metadata</span></div><div class="summary-title">Dict(...)</div></summary><div class="complex-value dict"><details class="pyglove dict"><summary><div class="summary-name">x<span class="tooltip">metadata.x</span></div><div class="summary-title">Dict(...)</div></summary><div class="complex-value dict"><details open class="pyglove int"><summary><div class="summary-name">z<span class="tooltip">metadata.x.z</span></div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details></div></details><details open class="pyglove int"><summary><div class="summary-name">y<span class="tooltip">metadata.y</span></div><div class="summary-title">int</div></summary><span class="simple-value int">2</span></details></div></details></div></div></details>
+        """
+    )
+    self.assert_html_content(
+        logging.LogEntry(
+            level='error', message='This is a longer message: 5 + 2 > 3',
+            time=time, metadata=dict(x=dict(z=1), y=2)
+        ).to_html(
+            extra_flags=dict(
+                max_summary_len_for_str=10,
+            ),
+            enable_summary_tooltip=False,
+        ),
+        """
+        <details open class="pyglove log-entry log-error"><summary><div class="summary-title log-error"><span class="log-time">12:30:45</span><span class="log-summary">This is a longer message: 5 + 2 &gt; 3</span></div></summary><div class="complex_value"><div class="log-metadata"><details open class="pyglove dict"><summary><div class="summary-name">metadata<span class="tooltip">metadata</span></div><div class="summary-title">Dict(...)</div></summary><div class="complex-value dict"><details open class="pyglove dict"><summary><div class="summary-name">x<span class="tooltip">metadata.x</span></div><div class="summary-title">Dict(...)</div></summary><div class="complex-value dict"><details open class="pyglove int"><summary><div class="summary-name">z<span class="tooltip">metadata.x.z</span></div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details></div></details><details open class="pyglove int"><summary><div class="summary-name">y<span class="tooltip">metadata.y</span></div><div class="summary-title">int</div></summary><span class="simple-value int">2</span></details></div></details></div></div></details>
         """
     )