langfun 0.1.2.dev202505060804__tar.gz → 0.1.2.dev202505080804__tar.gz

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/PKG-INFO

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

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/eval/v2/experiment.py

@@ -382,6 +382,7 @@ class Experiment(lf.Component, pg.views.HtmlTreeView.Extension):
       warm_start_from: str | None = None,
       filter: Callable[['Experiment'], bool] | None = None,   # pylint: disable=redefined-builtin
       example_ids: list[int] | None = None,
+      shuffle_inputs: bool = False,
       raise_if_has_error: bool = False,
       reprocess: bool | list[int] = False,
       generate_example_html: Literal['new', 'all', 'no'] | list[int] = 'new',
@@ -431,6 +432,8 @@ class Experiment(lf.Component, pg.views.HtmlTreeView.Extension):
       filter: A filter function to decide whether an experiment should be run
         or not.
       example_ids: The example IDs to run. If None, it will run all examples.
+      shuffle_inputs: If True, the order of evaluatin examples will be shuffled.
+        Neverthless, the example ID remains unchanged for each example.
       raise_if_has_error: If True, it will raise an error if any example fails.
         Otherwise, it will continue and report the error in the output.
       reprocess: A boolean or a list of example IDs. If boolean, it indicates
@@ -470,6 +473,7 @@ class Experiment(lf.Component, pg.views.HtmlTreeView.Extension):
             warm_start_from=warm_start_from,
             filter=filter,
             example_ids=example_ids,
+            shuffle_inputs=shuffle_inputs,
             raise_if_has_error=raise_if_has_error,
             reprocess=reprocess,
             generate_example_html=generate_example_html,
@@ -816,6 +820,14 @@ class Run(pg.Object, pg.views.html.HtmlTreeView.Extension):
       )
   ] = None
 
+  shuffle_inputs: Annotated[
+      bool,
+      (
+          'If True, the order of evaluating examples will be shuffled.'
+          'Otherwise an increasing order will be used.'
+      )
+  ] = False
+
   raise_if_has_error: Annotated[
       bool,
       (

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/eval/v2/runners.py

@@ -356,6 +356,9 @@ class RunnerBase(Runner):
                   input=evaluation.example_input_by_id(example_id)
               ) for example_id in self.current_run.example_ids
           )
+        if self.current_run.shuffle_inputs:
+          items = list(items)
+          random.shuffle(items)
         self._evaluate_items(evaluation, items)
 
       if cache:

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/eval/v2/runners_test.py

@@ -163,6 +163,15 @@ class RunnerTest(unittest.TestCase):
     self.assertEqual(plugin.started_example_ids, [5, 7, 9] * 6)
     self.assertEqual(plugin.completed_example_ids, [5, 7, 9] * 6)
 
+  def test_shuffle_inputs(self):
+    root_dir = os.path.join(tempfile.gettempdir(), 'test_shuffle_inputs')
+    exp = eval_test_helper.test_experiment()
+    plugin = TestPlugin()
+    run = exp.run(
+        root_dir, runner='sequential', plugins=[plugin], shuffle_inputs=True
+    )
+    self.assertTrue(run.shuffle_inputs)
+
   def test_filter(self):
     plugin = TestPlugin()
     exp = eval_test_helper.test_experiment()

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/llms/__init__.py

@@ -40,6 +40,7 @@ from langfun.core.llms.azure_openai import AzureOpenAI
 
 # Gemini models.
 from langfun.core.llms.google_genai import GenAI
+from langfun.core.llms.google_genai import Gemini25ProPreview_20250506
 from langfun.core.llms.google_genai import Gemini25FlashPreview_20250417
 from langfun.core.llms.google_genai import Gemini25ProPreview_20250325
 from langfun.core.llms.google_genai import Gemini2Flash
@@ -77,6 +78,7 @@ from langfun.core.llms.vertexai import VertexAIGeminiExp_20241206
 from langfun.core.llms.vertexai import VertexAIGemini25ProExp_20250325
 from langfun.core.llms.vertexai import VertexAIGemini25ProPreview_20250325
 from langfun.core.llms.vertexai import VertexAIGemini25FlashPreview_20250417
+from langfun.core.llms.vertexai import VertexAIGemini25ProPreview_20250506
 
 # For backward compatibility.
 GeminiPro1_5 = Gemini15Pro

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/llms/gemini.py

@@ -151,6 +151,29 @@ SUPPORTED_MODELS = [
     #
     # Production models.
     #
+    # Gemini 2.5 Pro Preview
+    GeminiModelInfo(
+        model_id='gemini-2.5-pro-preview-05-06',
+        in_service=True,
+        provider=pg.oneof(['Google GenAI', ' VertexAI']),
+        model_type='instruction-tuned',
+        description='Gemini 2.5 Pro.',
+        release_date=datetime.datetime(2025, 5, 6),
+        input_modalities=GeminiModelInfo.ALL_SUPPORTED_INPUT_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=1_048_576,
+            max_output_tokens=65_536,
+        ),
+        pricing=GeminiModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=1.25,
+            cost_per_1m_input_tokens=1.25,
+            cost_per_1m_output_tokens=10.0,
+        ),
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=2000,
+            max_tokens_per_minute=4_000_000,
+        )
+    ),
     # Gemini 2.5 Flash Preview
     GeminiModelInfo(
         model_id='gemini-2.5-flash-preview-04-17',

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/llms/google_genai.py

@@ -106,6 +106,10 @@ class GeminiExp_20241206(GenAI):
 #
 # Production models.
 #
+class Gemini25ProPreview_20250506(GenAI):
+  """Gemini 2.5 Pro model launched on 05/06/2025."""
+
+  model = 'gemini-2.5-pro-preview-05-06'
 
 
 class Gemini25FlashPreview_20250417(GenAI):

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/llms/vertexai.py

@@ -173,9 +173,13 @@ class VertexAIGemini(VertexAI, gemini.Gemini):
   def model_info(self) -> gemini.GeminiModelInfo:
     return super().model_info.clone(override=dict(provider='VertexAI'))
 
+
 #
 # Production models.
 #
+class VertexAIGemini25ProPreview_20250506(VertexAIGemini):  # pylint: disable=invalid-name
+  """Gemini 2.5 Pro model launched on 05/06/2025."""
+  model = 'gemini-2.5-pro-preview-05-06'
 
 
 class VertexAIGemini25FlashPreview_20250417(VertexAIGemini):  # pylint: disable=invalid-name

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/memories/conversation_history.py

@@ -43,19 +43,19 @@ class ConversationHistory(lf.Memory):
       messages.append(r[1])
     return messages
 
-  def _recollect(self, **kwargs) -> lf.MemoryRecord:
-    return lf.MemoryRecord(
-        '\n'.join([f'{m.sender}: {m.text}' for m in self.messages]))
+  def _recollect(self, **kwargs) -> str:
+    return '\n'.join([f'{m.sender}: {m.text}' for m in self.messages])
 
   def _remember(
       self,
-      input_message: lf.Message,
-      output_message: lf.Message | None = None,
+      value: tuple[str | lf.Message, str | lf.Message],
       **kwargs
   ) -> None:
     if self.max_turns and self.max_turns == len(self._turns):
       self._turns.pop(0)
-    self._turns.append((input_message, output_message))
+    self._turns.append(
+        (lf.UserMessage.from_value(value[0]), lf.AIMessage.from_value(value[1]))
+    )
 
   def _reset(self, **kwargs) -> None:
     self._turns = []

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/memories/conversation_history_test.py

@@ -13,58 +13,62 @@
 # limitations under the License.
 """Base memory test."""
 
-import inspect
 import unittest
 import langfun.core as lf
 from langfun.core.memories.conversation_history import ConversationHistory
+import pyglove as pg
 
 
 class ConversationHistoryTest(unittest.TestCase):
 
   def test_history_with_no_round_limit(self):
     m = ConversationHistory()
-    m.remember('hi', 'hello')
+    m.remember(('hi', 'hello'))
     m.remember(
-        'how are you',
-        'Fine, thank you. Anything I can help with?',
+        ('how are you', 'Fine, thank you. Anything I can help with?'),
     )
     m.remember(
-        'Not for now, bye.',
-        'Okay, bye!',
+        ('Not for now, bye.', 'Okay, bye!'),
     )
     self.assertEqual(len(m.turns), 3)
     self.assertEqual(len(m.messages), 6)
-    self.assertEqual(
-        m.recollect(),
-        lf.MemoryRecord(inspect.cleandoc("""
-            User: hi
-            AI: hello
-            User: how are you
-            AI: Fine, thank you. Anything I can help with?
-            User: Not for now, bye.
-            AI: Okay, bye!
-            """)),
+    self.assertTrue(
+        pg.eq(
+            m.recollect(),
+            lf.Template(
+                """
+                User: hi
+                AI: hello
+                User: how are you
+                AI: Fine, thank you. Anything I can help with?
+                User: Not for now, bye.
+                AI: Okay, bye!
+                """
+            )
+        )
     )
 
   def test_history_with_round_limit(self):
     m = ConversationHistory(max_turns=1)
-    m.remember('hi', 'hello')
+    m.remember(('hi', 'hello'))
     m.remember(
-        'how are you',
-        'Fine, thank you. Anything I can help with?',
+        ('how are you', 'Fine, thank you. Anything I can help with?'),
     )
     m.remember(
-        'Not for now, bye.',
-        'Okay, bye!',
+        ('Not for now, bye.', 'Okay, bye!'),
     )
     self.assertEqual(len(m.turns), 1)
     self.assertEqual(len(m.messages), 2)
-    self.assertEqual(
-        m.recollect(),
-        lf.MemoryRecord(inspect.cleandoc("""
-            User: Not for now, bye.
-            AI: Okay, bye!
-            """)),
+    self.assertTrue(
+        pg.eq(
+            m.recollect(),
+            lf.Template(
+                """
+                User: Not for now, bye.
+                AI: Okay, bye!
+                """
+            )
+        )
     )
 
 

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/memory.py

@@ -14,7 +14,9 @@
 """Interface for memories."""
 
 import abc
-from langfun.core import message as message_lib
+from typing import Any
+
+from langfun.core import template as template_lib
 from langfun.core.component import Component
 from langfun.core.natural_language import NaturalLanguageFormattable
 
@@ -30,40 +32,29 @@ class Memory(NaturalLanguageFormattable, Component):
   """
 
   def natural_language_format(self) -> str:
-    return self.recollect().text
+    return self.recollect().render().text
 
-  def recollect(self, **kwargs) -> message_lib.MemoryRecord:
+  def recollect(self, **kwargs) -> template_lib.Template:
     """Recollects a message from the memory."""
-    return self._recollect(**kwargs)
+    return template_lib.Template.from_value(self._recollect(**kwargs))
 
   def remember(
       self,
-      input_message: str | message_lib.Message,
-      output_message: str | message_lib.Message,
+      value: Any,
       **kwargs
-  ) -> str:
-    if isinstance(input_message, str):
-      input_message = message_lib.UserMessage(input_message)
-    if isinstance(output_message, str):
-      output_message = message_lib.AIMessage(output_message)
-    self._remember(input_message, output_message, **kwargs)
-    return output_message.text
+  ) -> None:
+    self._remember(value, **kwargs)
 
   def reset(self, **kwargs) -> None:
     """Resets the memory."""
-    self._reset()
+    self._reset(**kwargs)
 
   @abc.abstractmethod
-  def _recollect(self, **kwargs) -> message_lib.MemoryRecord:
+  def _recollect(self, **kwargs) -> str | template_lib.Template:
     """Recollects a message from the memory."""
 
   @abc.abstractmethod
-  def _remember(
-      self,
-      input_message: message_lib.Message,
-      output_message: message_lib.Message,
-      **kwargs
-  ) -> None:
+  def _remember(self, value: Any, **kwargs) -> None:
     """Remembers the input message and the output message."""
 
   @abc.abstractmethod

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/structured/schema.py

@@ -185,10 +185,14 @@ class Schema(
   def class_dependencies(
       self,
       include_base_classes: bool = True,
-      include_subclasses: bool = True) -> list[Type[Any]]:
+      include_subclasses: bool = True,
+      include_generated_subclasses: bool = False) -> list[Type[Any]]:
     """Returns a list of class dependencies for current schema."""
     return class_dependencies(
-        self.spec, include_base_classes, include_subclasses
+        self.spec,
+        include_base_classes,
+        include_subclasses,
+        include_generated_subclasses
     )
 
   @classmethod
@@ -247,6 +251,7 @@ def class_dependencies(
     ],
     include_base_classes: bool = True,
     include_subclasses: bool = True,
+    include_generated_subclasses: bool = False,
 ) -> list[Type[Any]]:
   """Returns a list of class dependencies from a value or specs."""
   if isinstance(value_or_spec, Schema):
@@ -301,7 +306,12 @@ def class_dependencies(
       # Check subclasses if available.
       if include_subclasses:
         for cls in vs.cls.__subclasses__():
-          if cls not in dependencies:
+          # NOTE(daiyip): To prevent LLM-generated "hallucinated" classes from
+          # polluting the generation space, classes dynamically created by
+          # 'eval' (which have __module__ == 'builtins') are excluded from
+          # dependencies by default.
+          if ((include_generated_subclasses or cls.__module__ != 'builtins')
+              and cls not in dependencies):
             _fill_dependencies(pg.typing.Object(cls), include_subclasses=True)
 
     if isinstance(vs, pg.typing.List):

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/structured/schema_test.py

@@ -144,6 +144,14 @@ class SchemaTest(unittest.TestCase):
       foo2: Foo | X
 
     schema = schema_lib.Schema([B])
+    v = schema_lib.structure_from_python(
+        """
+        class C(B):
+          pass
+        """,
+        global_vars=dict(B=B)
+    )
+    self.assertEqual(v.__module__, 'builtins')
     self.assertEqual(schema.class_dependencies(), [Foo, A, Bar, X, B])
 
   def test_class_dependencies_non_pyglove(self):
@@ -162,6 +170,14 @@ class SchemaTest(unittest.TestCase):
     class BB(AA):
       foo2: Baz | XX
 
+    v = schema_lib.structure_from_python(
+        """
+        class CC(BB):
+          pass
+        """,
+        global_vars=dict(BB=BB)
+    )
+    self.assertEqual(v.__module__, 'builtins')
     schema = schema_lib.Schema([AA])
     self.assertEqual(schema.class_dependencies(), [Baz, AA, XX, BB])
 

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun/core/templates/conversation.py

@@ -90,7 +90,7 @@ class Conversation(Completion):
       self, input_message: lf.Message | str, lm_response: lf.Message | str
   ) -> None:
     """Adds a turn."""
-    self.memory.remember(input_message, lm_response)
+    self.memory.remember((input_message, lm_response))
 
   def reset(self) -> None:
     """Resets current conversation."""

{langfun-0.1.2.dev202505060804 → langfun-0.1.2.dev202505080804}/langfun.egg-info/PKG-INFO

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