langfun 0.0.2.dev20240330__py3-none-any.whl → 0.0.2.dev20240429__py3-none-any.whl

langfun/core/structured/parsing_test.py

@@ -17,11 +17,9 @@ import inspect
 import unittest
 
 import langfun.core as lf
-from langfun.core import coding
 from langfun.core.llms import fake
 from langfun.core.structured import mapping
 from langfun.core.structured import parsing
-from langfun.core.structured import schema as schema_lib
 import pyglove as pg
 
 
@@ -255,7 +253,7 @@ class ParseStructurePythonTest(unittest.TestCase):
         override_attrs=True,
     ):
       with self.assertRaisesRegex(
-          coding.CodeError,
+          mapping.MappingError,
           'name .* is not defined',
       ):
         parsing.parse('three', int)
@@ -280,13 +278,15 @@ class ParseStructurePythonTest(unittest.TestCase):
         ),
         1,
     )
+    r = parsing.parse(
+        'the answer is 1', int, user_prompt='what is 0 + 1?', lm=lm,
+        returns_message=True
+    )
     self.assertEqual(
-        parsing.parse(
-            'the answer is 1', int, user_prompt='what is 0 + 1?', lm=lm,
-            returns_message=True
-        ),
+        r,
         lf.AIMessage(
             '1', score=1.0, result=1, logprobs=None,
+            usage=lf.LMSamplingUsage(652, 1, 653),
             tags=['lm-response', 'lm-output', 'transformed']
         ),
     )
@@ -544,7 +544,7 @@ class ParseStructureJsonTest(unittest.TestCase):
         override_attrs=True,
     ):
       with self.assertRaisesRegex(
-          schema_lib.JsonError,
+          mapping.MappingError,
           'No JSON dict in the output',
       ):
         parsing.parse('three', int, protocol='json')
@@ -634,13 +634,18 @@ class CallTest(unittest.TestCase):
       )
 
   def test_call_with_returning_message(self):
+    r = parsing.call(
+        'Compute 1 + 2', int, lm=fake.StaticSequence(['three', '3']),
+        returns_message=True
+    )
     self.assertEqual(
-        parsing.call(
-            'Compute 1 + 2', int, lm=fake.StaticSequence(['three', '3']),
-            returns_message=True
-        ),
+        r,
         lf.AIMessage(
-            '3', result=3, score=1.0, logprobs=None,
+            '3',
+            result=3,
+            score=1.0,
+            logprobs=None,
+            usage=lf.LMSamplingUsage(315, 1, 316),
             tags=['lm-response', 'lm-output', 'transformed']
         ),
     )

langfun/core/structured/prompting.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Symbolic query."""
 
-from typing import Any, Type, Union
+from typing import Any, Callable, Type, Union
 
 import langfun.core as lf
 from langfun.core.structured import mapping
@@ -78,7 +78,9 @@ class QueryStructurePython(QueryStructure):
 
       {{ output_title }}:
         ```python
-        Answer(final_answer=2)
+        Answer(
+          final_answer=2
+        )
         ```
       """
   protocol = 'python'
@@ -107,6 +109,7 @@ def query(
     lm: lf.LanguageModel | None = None,
     examples: list[mapping.MappingExample] | None = None,
     cache_seed: int | None = 0,
+    response_postprocess: Callable[[str], str] | None = None,
     autofix: int = 0,
     autofix_lm: lf.LanguageModel | None = None,
     protocol: schema_lib.SchemaProtocol = 'python',
@@ -159,6 +162,9 @@ def query(
     cache_seed: Seed for computing cache key. The cache key is determined by a
       tuple of (lm, prompt, cache seed). If None, cache will be disabled for
       the query even cache is configured by the LM.
+    response_postprocess: An optional callable object to process the raw LM
+      response before parsing it into the final output object. If None, the
+      raw LM response will not be processed.
     autofix: Number of attempts to auto fix the generated code. If 0, autofix is
       disabled. Auto-fix is not supported for 'json' protocol.
     autofix_lm: The language model to use for autofix. If not specified, the
@@ -170,8 +176,11 @@ def query(
       returning the structured `message.result`.
     skip_lm: If True, returns the rendered prompt as a UserMessage object.
       otherwise return the LLM response based on the rendered prompt.
-    **kwargs: Keyword arguments passed to the
-      `lf.structured.NaturalLanguageToStructureed` transform.
+    **kwargs: Keyword arguments passed to render the prompt or configure the 
+      `lf.structured.Mapping` class. Notable kwargs are:
+      - template_str: Change the root template for query.
+      - preamble: Change the preamble for query.
+      - mapping_template: Change the template for each mapping examle.
 
   Returns:
     The result based on the schema.
@@ -188,13 +197,24 @@ def query(
     output = lf.LangFunc.from_value(prompt, **kwargs)(
         lm=lm, cache_seed=cache_seed, skip_lm=skip_lm
     )
+    if response_postprocess:
+      processed_text = response_postprocess(output.text)
+      if processed_text != output.text:
+        output = lf.AIMessage(processed_text, source=output)
     return output if returns_message else output.text
 
   # Query with structured output.
+  prompt_kwargs = kwargs.copy()
+
+  # NOTE(daiyip): when `template_str` is passed in, it's intended to modify the
+  # QueryStructure template string. Therefore, we pop out the argument for
+  # prompt rendering.
+  prompt_kwargs.pop('template_str', None)
+
   if isinstance(prompt, str):
-    prompt = lf.Template(prompt, **kwargs)
+    prompt = lf.Template(prompt, **prompt_kwargs)
   elif isinstance(prompt, lf.Template):
-    prompt = prompt.rebind(**kwargs)
+    prompt = prompt.rebind(**prompt_kwargs, raise_on_no_change=False)
 
   if isinstance(prompt, lf.Template):
     prompt = prompt.render(lm=lm)
@@ -206,6 +226,7 @@ def query(
       schema=schema,
       default=default,
       examples=examples,
+      response_postprocess=response_postprocess,
       autofix=autofix if protocol == 'python' else 0,
       **kwargs,
   )(

langfun/core/structured/prompting_test.py

@@ -17,12 +17,10 @@ import inspect
 import unittest
 
 import langfun.core as lf
-from langfun.core import coding
 from langfun.core import modalities
 from langfun.core.llms import fake
 from langfun.core.structured import mapping
 from langfun.core.structured import prompting
-from langfun.core.structured import schema as schema_lib
 import pyglove as pg
 
 
@@ -77,6 +75,7 @@ class QueryTest(unittest.TestCase):
             result=1,
             score=1.0,
             logprobs=None,
+            usage=lf.LMSamplingUsage(323, 1, 324),
             tags=['lm-response', 'lm-output', 'transformed'],
         ),
     )
@@ -116,12 +115,59 @@ class QueryTest(unittest.TestCase):
         y=2,
         lm=lm.clone(),
         expected_snippet=(
-            'Please respond to the last INPUT_OBJECT with OUTPUT_OBJECT'
-            ' according to OUTPUT_TYPE.\n\nINPUT_OBJECT:\n  1 + 1'
-            ' =\n\nOUTPUT_TYPE:\n  Answer\n\n  ```python\n  class Answer:\n   '
-            ' final_answer: int\n  ```\n\nOUTPUT_OBJECT:\n  ```python\n '
-            ' Answer(final_answer=2)\n  ```\n\nINPUT_OBJECT:\n  What is 1 +'
-            ' 2?\n\nOUTPUT_TYPE:\n  int\n\nOUTPUT_OBJECT:'
+            'Please respond to the last INPUT_OBJECT with OUTPUT_OBJECT '
+            'according to OUTPUT_TYPE.\n\n'
+            'INPUT_OBJECT:\n  1 + 1 =\n\n'
+            'OUTPUT_TYPE:\n'
+            '  Answer\n\n'
+            '  ```python\n'
+            '  class Answer:\n'
+            '    final_answer: int\n'
+            '  ```\n\n'
+            'OUTPUT_OBJECT:\n'
+            '  ```python\n'
+            '  Answer(\n'
+            '    final_answer=2\n'
+            '  )\n'
+            '  ```\n\n'
+            'INPUT_OBJECT:\n'
+            '  What is 1 + 2?\n\n'
+            'OUTPUT_TYPE:\n'
+            '  int\n\n'
+            'OUTPUT_OBJECT:'
+        ),
+    )
+
+  def test_str_to_structure_render_custom_template(self):
+    lm = fake.StaticResponse('1')
+    self.assert_render(
+        'What is {{x}} + {{y}}?',
+        int,
+        x=1,
+        y=2,
+        lm=lm.clone(),
+        template_str='!!{{ DEFAULT }}!!',
+        expected_snippet=(
+            '!!Please respond to the last INPUT_OBJECT with OUTPUT_OBJECT '
+            'according to OUTPUT_TYPE.\n\n'
+            'INPUT_OBJECT:\n  1 + 1 =\n\n'
+            'OUTPUT_TYPE:\n'
+            '  Answer\n\n'
+            '  ```python\n'
+            '  class Answer:\n'
+            '    final_answer: int\n'
+            '  ```\n\n'
+            'OUTPUT_OBJECT:\n'
+            '  ```python\n'
+            '  Answer(\n'
+            '    final_answer=2\n'
+            '  )\n'
+            '  ```\n\n'
+            'INPUT_OBJECT:\n'
+            '  What is 1 + 2?\n\n'
+            'OUTPUT_TYPE:\n'
+            '  int\n\n'
+            'OUTPUT_OBJECT:!!'
         ),
     )
 
@@ -264,7 +310,9 @@ class QueryStructurePythonTest(unittest.TestCase):
 
             OUTPUT_OBJECT:
               ```python
-              Answer(final_answer=2)
+              Answer(
+                final_answer=2
+              )
               ```
 
             INPUT_OBJECT:
@@ -308,7 +356,9 @@ class QueryStructurePythonTest(unittest.TestCase):
 
             OUTPUT_OBJECT:
               ```python
-              Answer(final_answer=2)
+              Answer(
+                final_answer=2
+              )
               ```
 
             INPUT_OBJECT:
@@ -420,7 +470,7 @@ class QueryStructurePythonTest(unittest.TestCase):
         override_attrs=True,
     ):
       with self.assertRaisesRegex(
-          coding.CodeError,
+          mapping.MappingError,
           'name .* is not defined',
       ):
         prompting.query('Compute 1 + 2', int)
@@ -436,6 +486,23 @@ class QueryStructurePythonTest(unittest.TestCase):
     ])
     self.assertEqual(prompting.query('what is 1 + 0', int, lm=lm, autofix=3), 1)
 
+  def test_response_postprocess(self):
+    with lf.context(
+        lm=fake.StaticResponse('<!-- some comment-->\n3'),
+        override_attrs=True,
+    ):
+      self.assertEqual(
+          prompting.query(
+              'Compute 1 + 2', response_postprocess=lambda x: x.split('\n')[1]),
+          '3'
+      )
+      self.assertEqual(
+          prompting.query(
+              'Compute 1 + 2', int,
+              response_postprocess=lambda x: x.split('\n')[1]),
+          3
+      )
+
 
 class QueryStructureJsonTest(unittest.TestCase):
 
@@ -641,7 +708,7 @@ class QueryStructureJsonTest(unittest.TestCase):
         override_attrs=True,
     ):
       with self.assertRaisesRegex(
-          schema_lib.JsonError,
+          mapping.MappingError,
           'No JSON dict in the output',
       ):
         prompting.query('Compute 1 + 2', int, protocol='json')

langfun/core/structured/schema.py

@@ -386,10 +386,12 @@ def class_definition(
   if schema.fields:
     for key, field in schema.items():
       if not isinstance(key, pg.typing.ConstStrKey):
-        raise TypeError(
+        pg.logging.warning(
             'Variable-length keyword arguments is not supported in '
-            f'structured parsing or query. Encountered: {field}'
+            f'structured parsing or query. Encountered: {cls}, Schema: {schema}'
         )
+        continue
+
       # Write field doc string as comments before the field definition.
       if field.description:
         for line in field.description.split('\n'):

langfun/core/structured/schema_generation_test.py

@@ -14,8 +14,8 @@
 import inspect
 import unittest
 
-import langfun.core.coding as lf_coding
 from langfun.core.llms import fake
+from langfun.core.structured import mapping
 from langfun.core.structured import schema_generation
 
 
@@ -92,7 +92,7 @@ class GenerateClassTest(unittest.TestCase):
     )
     self.assertIs(cls.__name__, 'B')
 
-    with self.assertRaises(lf_coding.CodeError):
+    with self.assertRaises(mapping.MappingError):
       schema_generation.generate_class(
           'Foo',
           'Generate a Foo class with a field pointing to another class A',

langfun/core/structured/schema_test.py

@@ -192,9 +192,9 @@ class SchemaTest(unittest.TestCase):
     self.assertEqual(schema.parse('{"result": 1}'), 1)
     schema = schema_lib.Schema(dict[str, int])
     self.assertEqual(
-        schema.parse(
-            '{"result": {"_type": "Unknown", "x": 1}}}', force_dict=True),
-        dict(x=1))
+        schema.parse('{"result": {"x": 1}}}'),
+        dict(x=1)
+    )
     with self.assertRaisesRegex(
         schema_lib.SchemaError, 'Expect .* but encountered .*'):
       schema.parse('{"result": "def"}')
@@ -459,9 +459,7 @@ class SchemaPythonReprTest(unittest.TestCase):
       x: str
       __kwargs__: typing.Any
 
-    with self.assertRaisesRegex(
-        TypeError, 'Variable-length keyword arguments is not supported'):
-      schema_lib.class_definition(C)
+    self.assertEqual(schema_lib.class_definition(C), 'class C:\n  x: str\n')
 
   def test_repr(self):
     class Foo(pg.Object):

langfun/core/template.py

@@ -38,13 +38,22 @@ NO_TEMPLATE_DOCSTR_SIGN = 'THIS IS NOT A TEMPLATE'
 _TLS_RENDER_STACK = '_template_render_stack'
 _TLS_RENDER_RESULT_CACHE = '_template_render_result_cache'
 
+# The prefix for fields or contextual attributes to be treated as additional
+# metadata for rendered message.
+_ADDITIONAL_METADATA_PREFIX = 'metadata_'
+
 
 class Template(
     natural_language.NaturalLanguageFormattable,
     component.Component,
     pg.typing.CustomTyping,
 ):
-  """Langfun string template."""
+  """Langfun string template.
+
+  Langfun uses jinja2 as its template engine. Pleaes check out
+  https://jinja.palletsprojects.com/en/3.1.x/templates/ for detailed
+  explanation on the template language.
+  """
 
   template_str: Annotated[
       str,
@@ -97,6 +106,11 @@ class Template(
       # Declare template variables as symbolic attributes.
       template_vars = Template.resolve_vars(template_str)
       for var_name in template_vars:
+        if 'DEFAULT' == var_name:
+          raise ValueError(
+              '`{{ DEFAULT }}` cannot be used in pre-configured templates. '
+              f'Encountered: {template_str!r}'
+          )
         # NOTE(daiyip): This is to avoid warning from accessing
         # `pg.Object.schema`, which was replaced by `pg.Object.__schema__`.
         if var_name == 'schema' or not hasattr(cls, var_name):
@@ -149,7 +163,7 @@ class Template(
     # TODO(daiyip): Consider to delay template parsing upon usage.
     unassigned_vars = {}
     for k in self._variables:
-      if not hasattr(self, k):
+      if k not in ('DEFAULT',) and not hasattr(self, k):
         unassigned_vars[k] = component.contextual()
     if unassigned_vars:
       self.rebind(unassigned_vars, skip_notification=True)
@@ -303,19 +317,19 @@ class Template(
               with modality.format_modality_as_ref():
                 rendered_text = self._template.render(**inputs)
 
+            # Carry additional metadata.
+            metadata = self.additional_metadata()
+
         if self.clean:
           rendered_text = rendered_text.strip()
 
-        # Fill the variables for rendering the template as metadata.
-        message = message_cls(
-            text=rendered_text,
-            metadata={
-                k: pg.Ref(v)
-                for k, v in inputs.items()
-                if not inspect.ismethod(v)
-            },
+        metadata.update(
+            {k: pg.Ref(v) for k, v in inputs.items() if not inspect.ismethod(v)}
         )
 
+        # Fill the variables for rendering the template as metadata.
+        message = message_cls(text=rendered_text, metadata=metadata)
+
         # Tag input as rendered message.
         message.tag(message_lib.Message.TAG_RENDERED)
 
@@ -340,6 +354,20 @@ class Template(
       top = pg.object_utils.thread_local_pop(_TLS_RENDER_STACK)
       assert top is self, (top, self)
 
+  def additional_metadata(self) -> dict[str, Any]:
+    """Returns additional metadta to be carried in the rendered message."""
+    metadata = {}
+    # Carry metadata from `lf.context`.
+    for k, v in component.all_contextual_values().items():
+      if k.startswith(_ADDITIONAL_METADATA_PREFIX):
+        metadata[k.removeprefix(_ADDITIONAL_METADATA_PREFIX)] = v
+
+    # Carry metadata from fields.
+    for k, v in self.sym_init_args.items():
+      if k.startswith(_ADDITIONAL_METADATA_PREFIX):
+        metadata[k.removeprefix(_ADDITIONAL_METADATA_PREFIX)] = v
+    return metadata
+
   #
   # Implements `pg.typing.CustomTyping`.
   #
@@ -380,6 +408,93 @@ class Template(
     # Override __hash__ since __eq__ has changed.
     return object.__hash__(self)
 
+  #
+  # Special methods.
+  #
+
+  @property
+  def DEFAULT(self) -> 'Template':
+    """Referring to the default value used for this template.
+
+    This method is intended to be used in template for referring to the default
+    value of current template. There are two scenarios:
+
+    Scenario 1: Use instance-level template_str to override the class default.
+
+    ```
+    class Foo(lf.Template):
+       '''Foo template.
+
+       This is {{x}}.
+       '''
+
+    f = Foo(template_str='<h1>{{DEFAULT}}</h1>', x=1)
+    f.render()
+
+    >> <h1>This is 1.</h1>
+    ```
+
+    Scenario 2: Use an ad-hoc template to override a predefined field.
+
+    ```
+    class Bar(lf.Template):
+      '''Bar template.
+
+      {{preamble}}
+      {{prompt}}
+      '''
+      preamble: lf.Template = lf.Template('You are a chat bot.')
+      prompt: lf.Template = lf.Template('User: hi')
+
+    b = Bar(preamble=lf.Template('<h1>{{DEFAULT}}<h1>'),
+            prompt=lf.Template('<h2>{{DEFAULT}}</h2>')
+    b.render()
+
+    >> <h1>You are a chat bot.<h1>
+    >> <h2>User: hi</h2>
+    ```
+
+    Returns:
+      The default (pre-configured) value used for this template.
+    """
+    base_template = self.__class__.__schema__['template_str'].default_value
+    if base_template == pg.MISSING_VALUE:
+      if not self.sym_path:
+        raise ValueError(
+            f'No DEFAULT template found for {self!r}: '
+            'The template neither has a default `template_str` nor is '
+            'contained under another object.'
+        )
+      key = self.sym_path.key
+      assert self.sym_parent is not None
+      assigned_field = self.sym_parent.sym_attr_field(key)
+      container_cls = self.sym_parent.__class__
+
+      if (
+          assigned_field is None
+          or assigned_field.default_value == pg.MISSING_VALUE
+      ):
+        raise ValueError(
+            f'No DEFAULT template found for {self!r}: '
+            f'`{container_cls.__name__}.{key}` '
+            'does not have a default value. '
+        )
+      base_template = assigned_field.default_value
+      if isinstance(base_template, Template):
+        base_template = base_template.template_str
+      if not isinstance(base_template, str):
+        raise ValueError(
+            f'No DEFAULT template found for {self!r}: The default '
+            f'value {base_template!r} of '
+            f'`{container_cls.__name__}.{key}` is not a '
+            '`lf.Template` object or str.'
+        )
+    t = Template(base_template)
+    # NOTE(daiyip): Set the parent of the newly created template to self so
+    # it could access all the contextual variables.
+    t.sym_setparent(self)
+    return t
+
 
 # Register converter from str to LangFunc, therefore we can always
 # pass strs to attributes that accept LangFunc.

langfun/core/template_test.py

@@ -16,6 +16,7 @@ import inspect
 import unittest
 
 from langfun.core import component
+from langfun.core import message as message_lib
 from langfun.core import modality
 from langfun.core import subscription
 from langfun.core.template import Template
@@ -311,6 +312,72 @@ class RenderTest(unittest.TestCase):
         'This is 1 and {{a}}',
     )
 
+  def test_render_with_default(self):
+
+    class Foo(Template):
+      """Foo.
+
+      This is {{x}}
+      """
+
+    f = Foo(template_str='!{{DEFAULT}}!', x=1)
+    self.assertEqual(f.DEFAULT.x, 1)
+    self.assertEqual(
+        f.render(), '!This is 1!'
+    )
+
+    class Bar(Template):
+      """Bar.
+
+      {{preamble}}
+      {{prompt}}
+      """
+
+      preamble: Template = Template('You are a chat bot.')
+      prompt: Template = Template('User: hi! {{name}}')
+
+    b = Bar(
+        preamble=Template('<h1>{{DEFAULT}}</h1>'),
+        prompt=Template('<h2>{{DEFAULT}}</h2>'),
+        name='Tom',
+    )
+    # Test variable access.
+    self.assertEqual(
+        b.render(),
+        inspect.cleandoc("""
+            <h1>You are a chat bot.</h1>
+            <h2>User: hi! Tom</h2>
+            """),
+    )
+
+    with self.assertRaisesRegex(ValueError, '`{{ DEFAULT }}` cannot be used'):
+
+      class Baz(Template):  # pylint: disable=unused-variable
+        """Baz.
+
+        {{DEFAULT}}
+        """
+
+    with self.assertRaisesRegex(
+        ValueError, 'The template neither has a default `template_str` nor'
+    ):
+      Template('{{DEFAULT}}').render()
+
+    d = pg.Dict(x=Template('{{DEFAULT}}'))
+    with self.assertRaisesRegex(
+        ValueError, 'does not have a default value'
+    ):
+      _ = d.x.DEFAULT
+
+    class Tes(pg.Object):
+      x: str | None = None
+
+    t = Tes(x=Template('{{DEFAULT}}'))
+    with self.assertRaisesRegex(
+        ValueError, 'is not a `lf.Template` object or str'
+    ):
+      _ = t.x.DEFAULT
+
   def test_bad_render(self):
     with self.assertRaises(ValueError):
       Template('Hello {{x}}').render(allow_partial=False)
@@ -427,6 +494,14 @@ class RenderTest(unittest.TestCase):
     # Test len.
     self.assert_partial(Template('Hello {{len(x)}}'), 'Hello {{len(x)}}')
 
+  def test_additional_metadata(self):
+    t = Template('hi', metadata_weights=1.0, y=2)
+    self.assertEqual(t.render(), message_lib.UserMessage('hi', weights=1.0))
+
+    t = Template('hi')
+    with component.context(metadata_weights=1.0, y=2):
+      self.assertEqual(t.render(), message_lib.UserMessage('hi', weights=1.0))
+
 
 class TemplateRenderEventTest(unittest.TestCase):
 

langfun/core/templates/selfplay_test.py

@@ -56,7 +56,9 @@ class SelfPlayTest(unittest.TestCase):
     g = NumberGuess(target_num=10)
 
     with lf.context(lm=NumberGuesser(guesses=[50, 20, 5, 10])):
-      self.assertEqual(g(), lf.AIMessage('10', score=0.0, logprobs=None))
+      self.assertEqual(
+          g(), lf.AIMessage('10', score=0.0, logprobs=None, usage=None)
+      )
 
     self.assertEqual(g.num_turns, 4)
 
@@ -64,7 +66,9 @@ class SelfPlayTest(unittest.TestCase):
     g = NumberGuess(target_num=10, max_turns=10)
 
     with lf.context(lm=NumberGuesser(guesses=[50, 20, 5, 2, 5, 4])):
-      self.assertEqual(g(), lf.AIMessage('2', score=0.0, logprobs=None))
+      self.assertEqual(
+          g(), lf.AIMessage('2', score=0.0, logprobs=None, usage=None)
+      )
 
     self.assertEqual(g.num_turns, 10)
 

{langfun-0.0.2.dev20240330.dist-info → langfun-0.0.2.dev20240429.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240330
+Version: 0.0.2.dev20240429
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,10 +21,11 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: absl-py >=1.0.0
 Requires-Dist: google-generativeai >=0.3.2
 Requires-Dist: jinja2 >=3.1.2
 Requires-Dist: openai ==0.27.2
-Requires-Dist: pyglove >=0.4.5.dev20240323
+Requires-Dist: pyglove >=0.4.5.dev20240423
 Requires-Dist: python-magic >=0.4.27
 Requires-Dist: requests >=2.31.0
 Requires-Dist: termcolor ==1.1.0