langfun 0.1.2.dev202504240804__tar.gz → 0.1.2.dev202504250804__tar.gz

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/PKG-INFO

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

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/agentic/action.py

@@ -20,6 +20,7 @@ import threading
 import time
 import typing
 from typing import Annotated, Any, Callable, Iterable, Iterator, Optional, Type, Union
+import uuid
 import langfun.core as lf
 from langfun.core import structured as lf_structured
 import pyglove as pg
@@ -63,7 +64,11 @@ class Action(pg.Object):
         lf.console.display(pg.view(session, name='agent_session'))
 
     with session.track_action(self):
+      pg.logging.info('Example %s starts action %s', session.id, repr(self))
       result = self.call(session=session, **kwargs)
+      pg.logging.info(
+          'Example %s ends action %s', session.id, self.__class__.__name__
+      )
 
       # For the top-level action, we store the session in the metadata.
       if new_session:
@@ -792,6 +797,8 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
     self._tls = threading.local()
     self._current_action = self.root
     self._current_execution = self.root.execution
+    if self.id is None:
+      self.rebind(id=uuid.uuid4().hex[-7:], skip_notification=True)
 
   #
   # Context-manager for information tracking.

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/agentic/action_test.py

@@ -68,6 +68,7 @@ class SessionTest(unittest.TestCase):
     self.assertEqual(foo(lm=lm), 3)
 
     session = foo.session
+    self.assertEqual(len(session.id), 7)
     self.assertIsNotNone(session)
     self.assertIsInstance(session.root.action, action_lib.RootAction)
     self.assertIs(session.current_action, session.root)
@@ -152,7 +153,8 @@ class SessionTest(unittest.TestCase):
     session.fatal('hi', x=1, y=2)
 
   def test_as_message(self):
-    session = action_lib.Session()
+    session = action_lib.Session(id='abc')
+    self.assertEqual(session.id, 'abc')
     self.assertIsInstance(session.as_message(), lf.AIMessage)
 
 

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/eval/v2/evaluation.py

@@ -169,9 +169,23 @@ class Evaluation(experiment_lib.Experiment):
     checkpointed = self._state.ckpt_example(example.id)
     with pg.timeit('evaluate') as timeit, lf.track_usages() as usage_summary:
       if checkpointed is None or checkpointed.has_error:
+        if checkpointed is None:
+          self.info(
+              f'Example {example.id} is being processed for the first time '
+              'as no prior run is found. '
+          )
+        else:
+          self.info(
+              f'Example {example.id} is being reprocessed as prior run '
+              f'contains error: {checkpointed.error}'
+          )
         example.start_time = time.time()
         self._process(example, raise_if_has_error=raise_if_has_error)
       else:
+        self.info(
+            f'Example {example.id} skipped processing as prior run '
+            'is available and error free.'
+        )
         example.start_time = checkpointed.start_time
 
         # Use the output and metadata obtained from the previous processing.
@@ -190,10 +204,12 @@ class Evaluation(experiment_lib.Experiment):
       # NOTE(daiyip): It's possible that metrics could use LLMs, so we need to
       # track the usage of the metrics separately.
       with pg.timeit('metric'):
+        self.info(f'Starting metric computation for example {example.id}.')
         metric_metadata = {}
         for metric in self.metrics:
           metric_metadata.update(metric.audit(example))
         example.metric_metadata = metric_metadata
+        self.info(f'Completed metric computation for example {example.id}.')
 
     # For previously processed examples, we keep the execution status for the
     # processing step.
@@ -315,6 +331,26 @@ class Evaluation(experiment_lib.Experiment):
     with self._log_lock:
       self._log_entries.append(log_entry)
 
+    # Also add system log.
+    match level:
+      case 'debug':
+        sys_log_func = pg.logging.debug
+      case 'info':
+        sys_log_func = pg.logging.info
+      case 'warning':
+        sys_log_func = pg.logging.warning
+      case 'error':
+        sys_log_func = pg.logging.error
+      case 'fatal':
+        sys_log_func = pg.logging.error
+      case _:
+        raise ValueError(f'Unsupported log level: {level}')
+
+    sys_log_func(
+        '%s: %s\nMetadata: %s',
+        self.id, message, pg.format(kwargs)
+    )
+
   def debug(self, message: str, **kwargs):
     """Logs a debug message to the session."""
     self._log(pg.logging.debug, 'debug', message, **kwargs)

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/eval/v2/runners.py

@@ -249,22 +249,23 @@ class RunnerBase(Runner):
       if example.error is None:
         experiment.progress.increment_processed()
         experiment.info(
-            f'Example {example.id} is successfully evaluated in '
-            f'{example.elapse:.2f} seconds.'    # pylint: disable=bad-whitespace
+            f'Example {example.id} is successfully evaluated (with process) in '
+            f'{example.elapse:.2f} seconds.'
         )
       else:
         experiment.progress.increment_failed()
         experiment.error(
             (
                 f'Failed to evaluate example {example.id} in'
-                f'{example.elapse:.2f} seconds.'  # pylint: disable=bad-whitespace
+                f'{example.elapse:.2f} seconds.'
             ),
             error=example.error
         )
     else:
       experiment.progress.increment_skipped()
       experiment.info(
-          f'Skipped example {example.id} as it is loaded from checkpoint.'
+          f'Example {example.id} is successfully evaluated (without reprocess) '
+          f'in {example.elapse:.2f} seconds.'
       )
 
     experiment.usage_summary.merge(example.usage_summary)

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/llms/rest.py

@@ -103,6 +103,8 @@ class REST(lf.LanguageModel):
       error_message = str(e)
       if 'REJECTED_CLIENT_THROTTLED' in error_message:
         raise lf.TemporaryLMError(error_message) from e
+      if 'UNREACHABLE_ERROR' in error_message:
+        raise lf.TemporaryLMError(error_message) from e
       raise lf.LMError(error_message) from e
 
   def _error(self, status_code: int, content: str) -> lf.LMError:
@@ -113,6 +115,7 @@ class REST(lf.LanguageModel):
         502,  # Bad gateway (upstream issue, might retry).
         503,  # Servers currently under load, retry after a brief wait.
         529,  # Overloaded, retry after a brief wait.
+        499,  # Client Closed Request
     ):
       error_cls = lf.TemporaryLMError
     else:

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/message.py

@@ -443,11 +443,14 @@ class Message(
     metadata = dict()
     last_char = None
     for i, chunk in enumerate(chunks):
-      if i > 0 and last_char not in ('\t', ' ', '\n'):
+      if i > 0 and last_char not in ('\t', ' ', '\n', None):
         fused_text.write(separator)
       if isinstance(chunk, str):
         fused_text.write(chunk)
-        last_char = chunk[-1]
+        if chunk:
+          last_char = chunk[-1]
+        else:
+          last_char = None
       else:
         assert isinstance(chunk, modality.Modality), chunk
         var_name = f'obj{ref_index}'

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/message_test.py

@@ -476,6 +476,15 @@ class MessageTest(unittest.TestCase):
         """
     )
 
+  def test_from_chunks_with_empty_str(self):
+    chunks = ['Hello', '', 'World']
+    msg = message.AIMessage.from_chunks(chunks)
+    self.assertEqual(msg.text, 'Hello World')
+
+    chunks = ['', 'hello']
+    msg = message.AIMessage.from_chunks(chunks)
+    self.assertEqual(msg.text, 'hello')
+
 
 class MessageConverterTest(unittest.TestCase):
 

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/structured/schema_test.py

@@ -71,7 +71,6 @@ class SchemaTest(unittest.TestCase):
     self.assert_schema(float, pg.typing.Float())
     self.assert_schema(str, pg.typing.Str())
     self.assert_schema(bool, pg.typing.Bool())
-    self.assert_schema(bool | None, pg.typing.Bool().noneable())
 
     # Top-level dictionary with 'result' as the only key is flattened.
     self.assert_schema(dict(result=int), pg.typing.Int())

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun/core/template_test.py

@@ -80,10 +80,10 @@ class BasicTest(unittest.TestCase):
 
   def test_custom_typing(self):
     class Foo(component.Component):
-      x: str | None
-      y: int | None
+      x: str | None = None
+      y: int | None = None
       z: str
-      p: component.Component | None
+      p: component.Component | None = None
 
     d = Foo(z='bar')
     # String template can be assigned to str.

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504250804}/langfun.egg-info/PKG-INFO

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