langfun 0.1.2.dev202504240804__tar.gz → 0.1.2.dev202504260803__tar.gz

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

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

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

@@ -15,11 +15,11 @@
 
 import abc
 import contextlib
-import datetime
 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
@@ -54,7 +54,9 @@ class Action(pg.Object):
       session: Optional['Session'] = None,
       *,
       show_progress: bool = True,
-      **kwargs) -> Any:
+      verbose: bool = False,
+      **kwargs
+  ) -> Any:
     """Executes the action."""
     new_session = session is None
     if new_session:
@@ -63,7 +65,17 @@ class Action(pg.Object):
         lf.console.display(pg.view(session, name='agent_session'))
 
     with session.track_action(self):
-      result = self.call(session=session, **kwargs)
+      if verbose:
+        session.info(f'Executing action {self!r}...', keep=False)
+
+      result = self.call(session=session, verbose=verbose, **kwargs)
+
+      if verbose:
+        session.info(
+            f'Action {self.__class__.__name__} completed successfully.',
+            keep=False,
+            result=result
+        )
 
       # For the top-level action, we store the session in the metadata.
       if new_session:
@@ -792,6 +804,11 @@ 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=f'session@{uuid.uuid4().hex[-7:]}',
+          skip_notification=True
+      )
 
   #
   # Context-manager for information tracking.
@@ -1044,35 +1061,39 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
     with self.track_queries():
       return lf_structured.query_output(response, schema=schema, **kwargs)
 
-  def _log(self, level: lf.logging.LogLevel, message: str, **kwargs):
-    self._current_execution.append(
-        lf.logging.LogEntry(
-            level=level,
-            time=datetime.datetime.now(),
-            message=message,
-            metadata=kwargs,
-        )
+  def _log(
+      self,
+      level: lf.logging.LogLevel,
+      message: str,
+      keep: bool,
+      **kwargs
+  ) -> None:
+    """Logs a message to the session."""
+    log_entry = lf.logging.log(
+        level, f'[{self.id}]: {message}]', **kwargs
     )
+    if keep:
+      self._current_execution.append(log_entry)
 
-  def debug(self, message: str, **kwargs):
+  def debug(self, message: str, keep: bool = True, **kwargs):
     """Logs a debug message to the session."""
-    self._log('debug', message, **kwargs)
+    self._log('debug', message, keep=keep, **kwargs)
 
-  def info(self, message: str, **kwargs):
+  def info(self, message: str, keep: bool = True, **kwargs):
     """Logs an info message to the session."""
-    self._log('info', message, **kwargs)
+    self._log('info', message, keep=keep, **kwargs)
 
-  def warning(self, message: str, **kwargs):
+  def warning(self, message: str, keep: bool = True, **kwargs):
     """Logs a warning message to the session."""
-    self._log('warning', message, **kwargs)
+    self._log('warning', message, keep=keep, **kwargs)
 
-  def error(self, message: str, **kwargs):
+  def error(self, message: str, keep: bool = True, **kwargs):
     """Logs an error message to the session."""
-    self._log('error', message, **kwargs)
+    self._log('error', message, keep=keep, **kwargs)
 
   def fatal(self, message: str, **kwargs):
     """Logs a fatal message to the session."""
-    self._log('fatal', message, **kwargs)
+    self._log('fatal', message, keep=True, **kwargs)
 
   def as_message(self) -> lf.AIMessage:
     """Returns the session as a message."""

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

@@ -65,9 +65,10 @@ class SessionTest(unittest.TestCase):
 
     lm = fake.StaticResponse('lm response')
     foo = Foo(1)
-    self.assertEqual(foo(lm=lm), 3)
+    self.assertEqual(foo(lm=lm, verbose=True), 3)
 
     session = foo.session
+    self.assertIn('session@', session.id)
     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.dev202504260803}/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.dev202504260803}/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.dev202504260803}/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.dev202504260803}/langfun/core/logging.py

@@ -17,10 +17,10 @@ import contextlib
 import datetime
 import functools
 import typing
-from typing import Any, Iterator, Literal
+from typing import Any, Callable, Iterator, Literal
 
 from langfun.core import component
-from langfun.core import console
+from langfun.core import console as console_lib
 import pyglove as pg
 
 
@@ -43,6 +43,22 @@ def get_log_level() -> LogLevel:
   return component.context_value('__event_log_level__', 'info')
 
 
+def system_log_func(level: LogLevel) -> Callable[..., None]:
+  match level:
+    case 'debug':
+      return pg.logging.debug
+    case 'info':
+      return pg.logging.info
+    case 'warning':
+      return pg.logging.warning
+    case 'error':
+      return pg.logging.error
+    case 'fatal':
+      return pg.logging.error
+    case _:
+      raise ValueError(f'Unsupported log level: {level}')
+
+
 class LogEntry(pg.Object, pg.views.HtmlTreeView.Extension):
   """Event log entry."""
   time: datetime.datetime
@@ -241,6 +257,7 @@ def log(level: LogLevel,
         message: str,
         *,
         indent: int = 0,
+        console: bool = False,
         **kwargs) -> LogEntry:
   """Logs a message."""
   entry = LogEntry(
@@ -250,35 +267,71 @@ def log(level: LogLevel,
       message=message,
       metadata=kwargs,
   )
+
   if entry.should_output(get_log_level()):
-    if console.under_notebook():
-      console.display(entry)
-    else:
+    if console_lib.under_notebook():
+      console_lib.display(entry)
+    elif console:
       # TODO(daiyip): Improve the console output formatting.
-      console.write(entry)
+      console_lib.write(entry)
+
+  if not console:
+    if kwargs:
+      message = f'{message} (metadata: {pg.format(kwargs)})'
+    system_log_func(level)(message)
   return entry
 
 
-def debug(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+def debug(
+    message: str,
+    *,
+    indent: int = 0,
+    console: bool = False,
+    **kwargs
+) -> LogEntry:
   """Logs a debug message to the session."""
-  return log('debug', message, indent=indent, **kwargs)
+  return log('debug', message, indent=indent, console=console, **kwargs)
 
 
-def info(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+def info(
+    message: str,
+    *,
+    indent: int = 0,
+    console: bool = False,
+    **kwargs
+) -> LogEntry:
   """Logs an info message to the session."""
-  return log('info', message, indent=indent, **kwargs)
+  return log('info', message, indent=indent, console=console, **kwargs)
 
 
-def warning(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+def warning(
+    message: str,
+    *,
+    indent: int = 0,
+    console: bool = False,
+    **kwargs
+) -> LogEntry:
   """Logs an info message to the session."""
-  return log('warning', message, indent=indent, **kwargs)
+  return log('warning', message, indent=indent, console=console, **kwargs)
 
 
-def error(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+def error(
+    message: str,
+    *,
+    indent: int = 0,
+    console: bool = False,
+    **kwargs
+) -> LogEntry:
   """Logs an error message to the session."""
-  return log('error', message, indent=indent, **kwargs)
+  return log('error', message, indent=indent, console=console, **kwargs)
 
 
-def fatal(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+def fatal(
+    message: str,
+    *,
+    indent: int = 0,
+    console: bool = False,
+    **kwargs
+) -> LogEntry:
   """Logs a fatal message to the session."""
-  return log('fatal', message, indent=indent, **kwargs)
+  return log('fatal', message, indent=indent, console=console, **kwargs)

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504260803}/langfun/core/logging_test.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 """Tests for langfun.core.logging."""
 
+import contextlib
 import datetime
 import inspect
+import io
 import unittest
 
 from langfun.core import logging
@@ -44,6 +46,13 @@ class LoggingTest(unittest.TestCase):
     self.assertEqual(logging.error('hi').level, 'error')
     self.assertEqual(logging.fatal('hi').level, 'fatal')
 
+  def test_log_without_system_logging(self):
+    with contextlib.redirect_stdout(io.StringIO()) as stdout:
+      logging.log('info', 'hi', indent=1, x=1, y=2, console=True)
+    self.assertIn(
+        'hi (metadata: {x=1, y=2})', stdout.getvalue()
+    )
+
   def test_repr_html(self):
     def assert_color(entry, color):
       self.assertIn(f'background-color: {color}', entry._repr_html_())

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504260803}/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.dev202504260803}/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.dev202504260803}/langfun/core/structured/querying.py

@@ -17,6 +17,7 @@ import contextlib
 import functools
 import time
 from typing import Annotated, Any, Callable, Iterator, Type, Union
+import uuid
 
 import langfun.core as lf
 from langfun.core.structured import mapping
@@ -118,6 +119,7 @@ def query(
     protocol: schema_lib.SchemaProtocol = 'python',
     returns_message: bool = False,
     skip_lm: bool = False,
+    invocation_id: str | None = None,
     **kwargs,
 ) -> Any:
   """Query one or more language models for structured or unstructured outputs.
@@ -263,6 +265,9 @@ def query(
       the final parsed result.
     skip_lm: If `True`, skips the LLM call and returns the rendered 
       prompt as a `UserMessage` object.
+    invocation_id: The ID of the query invocation, which will be passed to
+      `lf.QueryInvocation` when `lf.trackIf `None`, a unique ID will
+      be generated.
     **kwargs: Additional keyword arguments for:
       - Rendering templates (e.g., `template_str`, `preamble`),
       - Configuring `lf.structured.Mapping`.
@@ -275,11 +280,12 @@ def query(
   """
     # Internal usage logging.
 
+  invocation_id = invocation_id or f'query@{uuid.uuid4().hex[-7:]}'
   # Multiple quries will be issued when `lm` is a list or `num_samples` is
   # greater than 1.
   if isinstance(lm, list) or num_samples != 1:
     def _single_query(inputs):
-      lm, example_i = inputs
+      i, (lm, example_i) = inputs
       return query(
           prompt,
           schema,
@@ -298,6 +304,7 @@ def query(
           protocol=protocol,
           returns_message=returns_message,
           skip_lm=skip_lm,
+          invocation_id=f'{invocation_id}:{i}',
           **kwargs,
       )
     lm_list = lm if isinstance(lm, list) else [lm]
@@ -317,7 +324,8 @@ def query(
 
     samples = []
     for _, output, error in lf.concurrent_map(
-        _single_query, query_inputs, max_workers=max(64, total_queries),
+        _single_query, enumerate(query_inputs),
+        max_workers=max(64, total_queries),
         ordered=True,
     ):
       if error is None:
@@ -409,6 +417,7 @@ def query(
       metadata.pop('usage', None)
 
       invocation = QueryInvocation(
+          id=invocation_id,
           input=pg.Ref(query_input),
           schema=(
               schema_lib.Schema.from_value(schema)
@@ -565,6 +574,11 @@ def _reward_fn(cls) -> Callable[
 class QueryInvocation(pg.Object, pg.views.HtmlTreeView.Extension):
   """A class to represent the invocation of `lf.query`."""
 
+  id: Annotated[
+      str,
+      'The ID of the query invocation.'
+  ]
+
   input: Annotated[
       Union[lf.Template, pg.Symbolic],
       'Mapping input of `lf.query`.'

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504260803}/langfun/core/structured/querying_test.py

@@ -1076,8 +1076,9 @@ class QueryInvocationTest(unittest.TestCase):
         'Activity(description="hi"',
     ])
     with querying.track_queries() as queries:
-      querying.query('foo', Activity, default=None, lm=lm)
+      querying.query('foo', Activity, default=None, lm=lm, invocation_id='123')
 
+    self.assertEqual(queries[0].id, '123')
     self.assertTrue(queries[0].has_error)
     self.assertIsInstance(queries[0].output, mapping.MappingError)
 
@@ -1088,6 +1089,7 @@ class QueryInvocationTest(unittest.TestCase):
     with querying.track_queries() as queries:
       querying.query('foo', Activity, lm=lm)
 
+    self.assertIn('query@', queries[0].id)
     self.assertIn('schema', queries[0].to_html_str())
     self.assertEqual(queries[0].lm_response.score, 1.0)
     self.assertFalse(queries[0].lm_response.is_cached)

{langfun-0.1.2.dev202504240804 → langfun-0.1.2.dev202504260803}/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.dev202504260803}/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.dev202504260803}/langfun.egg-info/PKG-INFO

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