langfun 0.0.2.dev20240608__py3-none-any.whl → 0.0.2.dev20240613__py3-none-any.whl

langfun/core/__init__.py

@@ -121,6 +121,9 @@ from langfun.core.memory import Memory
 # Utility for console output.
 from langfun.core import console
 
+# Helpers for implementing _repr_xxx_ methods.
+from langfun.core import repr_utils
+
 # Utility for event logging.
 from langfun.core import logging
 

langfun/core/modalities/mime.py

@@ -1,4 +1,4 @@
-# Copyright 2023 The Langfun Authors
+# Copyright 2024 The Langfun Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -53,19 +53,21 @@ class Mime(lf.Modality):
 
   @functools.cached_property
   def is_text(self) -> bool:
-    return self.mime_type.startswith(
-        (
-            'text/',
-            'application/javascript',
-            'application/json',
-            'application/ld+json',
-            'application/plain',
-            'application/xhtml+xml',
-            'application/xml',
-            'application/x-tex',
-            'application/x-yaml',
-        )
-    )
+    return self.mime_type.startswith((
+        'text/',
+        'application/javascript',
+        'application/json',
+        'application/ld+json',
+        'application/plain',
+        'application/rtf',
+        'application/xhtml+xml',
+        'application/xml',
+        'application/x-javascript',
+        'application/x-python-code',
+        'application/x-tex',
+        'application/x-typescript',
+        'application/x-yaml',
+    ))
 
   @property
   def is_binary(self) -> bool:

langfun/core/modalities/mime_test.py

@@ -32,6 +32,14 @@ def mock_readfile(*args, **kwargs):
 
 class CustomMimeTest(unittest.TestCase):
 
+  def test_is_text(self):
+    self.assertTrue(mime.Custom('text/plain', b'foo').is_text)
+    self.assertTrue(mime.Custom('text/xml', b'foo').is_text)
+    self.assertTrue(mime.Custom('application/json', b'foo').is_text)
+    self.assertTrue(mime.Custom('application/x-python-code', b'foo').is_text)
+    self.assertFalse(mime.Custom('application/pdf', b'foo').is_text)
+    self.assertFalse(mime.Custom('application/octet-stream', b'foo').is_text)
+
   def test_from_byes(self):
     content = mime.Mime.from_bytes(b'hello')
     self.assertIs(content.__class__, mime.Mime)

langfun/core/repr_utils.py

@@ -0,0 +1,83 @@
+# Copyright 2024 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Helpers for implementing _repr_xxx_ methods."""
+
+import collections
+import contextlib
+import io
+from typing import Iterator
+
+from langfun.core import component
+
+
+@contextlib.contextmanager
+def share_parts() -> Iterator[dict[str, int]]:
+  """Context manager for defining the context (scope) of shared content.
+
+  Under the context manager, call to `lf.write_shared` with the same content
+  will be written only once. This is useful for writing shared content such as
+  shared style and script sections in the HTML.
+
+  Example:
+    ```
+    class Foo(pg.Object):
+      def _repr_html_(self) -> str:
+        s = io.StringIO()
+        lf.repr_utils.write_shared_part(s, '<style>..</style>')
+        lf.repr_utils.write_shared_part(s, '<script>..</script>')
+        return s.getvalue()
+
+    with lf.repr_utils.share_parts() as share_parts:
+      # The <style> and <script> section will be written only once.
+      lf.console.display(Foo())
+      lf.console.display(Foo())
+
+    # Assert that the shared content is attempted to be written twice.
+    assert share_parts['<style>..</style>'] == 2
+    ```
+
+  Yields:
+    A dictionary mapping the shared content to the number of times it is
+    attempted to be written.
+  """
+  context = component.context_value(
+      '__shared_parts__', collections.defaultdict(int)
+  )
+  with component.context(__shared_parts__=context):
+    try:
+      yield context
+    finally:
+      pass
+
+
+def write_maybe_shared(s: io.StringIO, content: str) -> bool:
+  """Writes a maybe shared part to an string stream.
+
+  Args:
+    s: The string stream to write to.
+    content: A maybe shared content to write.
+
+  Returns:
+    True if the content is written to the string. False if the content is
+    already written under the same share context.
+  """
+  context = component.context_value('__shared_parts__', None)
+  if context is None:
+    s.write(content)
+    return True
+  written = content in context
+  if not written:
+    s.write(content)
+  context[content] += 1
+  return not written

langfun/core/repr_utils_test.py

@@ -0,0 +1,58 @@
+# Copyright 2024 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for langfun.core.repr_utils."""
+
+import io
+import unittest
+
+from langfun.core import repr_utils
+
+
+class SharingContentTest(unittest.TestCase):
+
+  def test_sharing(self):
+    s = io.StringIO()
+
+    self.assertTrue(repr_utils.write_maybe_shared(s, '<hr>'))
+    self.assertTrue(repr_utils.write_maybe_shared(s, '<hr>'))
+
+    with repr_utils.share_parts() as ctx1:
+      self.assertTrue(repr_utils.write_maybe_shared(s, '<style></style>'))
+      self.assertFalse(repr_utils.write_maybe_shared(s, '<style></style>'))
+
+      with repr_utils.share_parts() as ctx2:
+        self.assertIs(ctx2, ctx1)
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style></style>'))
+        self.assertTrue(repr_utils.write_maybe_shared(s, '<style>a</style>'))
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style>a</style>'))
+        self.assertTrue(repr_utils.write_maybe_shared(s, '<style>b</style>'))
+
+      with repr_utils.share_parts() as ctx3:
+        self.assertIs(ctx3, ctx1)
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style></style>'))
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style>a</style>'))
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style>a</style>'))
+        self.assertFalse(repr_utils.write_maybe_shared(s, '<style>b</style>'))
+
+    self.assertEqual(
+        s.getvalue(),
+        '<hr><hr><style></style><style>a</style><style>b</style>'
+    )
+    self.assertEqual(ctx1['<style></style>'], 4)
+    self.assertEqual(ctx1['<style>b</style>'], 2)
+    self.assertEqual(ctx1['<style>a</style>'], 4)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/structured/completion.py

@@ -30,7 +30,7 @@ class CompleteStructure(mapping.Mapping):
 
   mapping_template = lf.Template("""
       {{ input_title }}:
-      {{ example.input_repr() | indent(2, True) }}
+      {{ example.input_repr(use_modality_ref=True) | indent(2, True) }}
 
       {%- if missing_type_dependencies(example.input) %}
 
@@ -45,13 +45,16 @@ class CompleteStructure(mapping.Mapping):
 
       {{ output_title }}:
       {%- if example.has_output %}
-      {{ example.output_repr() | indent(2, True) }}
+      {{ example.output_repr(use_modality_ref=True) | indent(2, True) }}
       {% endif -%}
       """)
 
   input_title = 'INPUT_OBJECT'
   output_title = 'OUTPUT_OBJECT'
   schema_title = 'CLASS_DEFINITIONS'
+  modality_refs_title: Annotated[
+      str, 'The section title for modality refs.'
+  ] = 'MODALITY_REFERENCES'
 
   preamble = lf.LangFunc(
       """
@@ -148,6 +151,28 @@ class CompleteStructure(mapping.Mapping):
     pg.traverse(self.input, _visit)
     return context
 
+  #
+  # Helper methods for handling modalities.
+  #
+
+  def has_modality_refs(self, value: Any) -> bool:
+    """Returns true if the value has modalities."""
+    return not isinstance(value, lf.Modality) and pg.contains(
+        value, type=lf.Modality
+    )
+
+  def modalities(self, value: Any) -> dict[str, lf.Modality]:
+    return lf.Modality.from_value(value)
+
+  def modality_refs_repr(self, value: Any) -> str:
+    with lf.modality.format_modality_as_ref(True):
+      return pg.format(
+          self.modalities(value),
+          compact=False,
+          verbose=False,
+          python_format=True,
+      )
+
 
 def complete(
     input_value: pg.Symbolic,

langfun/core/structured/mapping.py

@@ -107,7 +107,11 @@ class MappingExample(lf.NaturalLanguageFormattable, lf.Component):
 
   @classmethod
   def value_repr(
-      cls, value: Any, protocol: schema_lib.SchemaProtocol = 'python', **kwargs
+      cls,
+      value: Any,
+      protocol: schema_lib.SchemaProtocol = 'python',
+      use_modality_ref: bool = False,
+      **kwargs
   ) -> str:
     if isinstance(value, str):
       return value
@@ -116,7 +120,7 @@ class MappingExample(lf.NaturalLanguageFormattable, lf.Component):
         return str(value)
 
     # Placehold modalities if they are present.
-    if pg.contains(value, type=lf.Modality):
+    if use_modality_ref and pg.contains(value, type=lf.Modality):
       value = lf.ModalityRef.placehold(value)
     return schema_lib.value_repr(protocol).repr(value, **kwargs)
 
@@ -243,13 +247,7 @@ class Mapping(lf.LangFunc):
       {{ input_title }}:
       {{ example.input_repr(protocol, compact=False) | indent(2, True) }}
 
-      {% if has_modality_refs(example.input) -%}
-      {{ modality_refs_title }}:
-      {{ modality_refs_repr(example.input) | indent(2, True) }}
-
-      {% endif -%}
-
-      {%- if example.schema -%}
+      {% if example.schema -%}
       {{ schema_title }}:
       {{ example.schema_repr(protocol) | indent(2, True) }}
 
@@ -270,10 +268,6 @@ class Mapping(lf.LangFunc):
 
   schema_title: Annotated[str, 'The section title for schema.'] = 'SCHEMA'
 
-  modality_refs_title: Annotated[
-      str, 'The section title for modality refs.'
-  ] = 'MODALITY_REFERENCES'
-
   protocol: Annotated[
       schema_lib.SchemaProtocol,
       'The protocol for representing the schema and value.',
@@ -378,24 +372,3 @@ class Mapping(lf.LangFunc):
     """Gets additional symbol definitions besides schema as globals."""
     return {'ModalityRef': lf.modality.ModalityRef}
 
-  #
-  # Helper methods for handling modalities.
-  #
-
-  def has_modality_refs(self, value: Any) -> bool:
-    """Returns true if the value has modalities."""
-    return not isinstance(value, lf.Modality) and pg.contains(
-        value, type=lf.Modality
-    )
-
-  def modalities(self, value: Any) -> dict[str, lf.Modality]:
-    return lf.Modality.from_value(value)
-
-  def modality_refs_repr(self, value: Any) -> str:
-    with lf.modality.format_modality_as_ref(True):
-      return pg.format(
-          self.modalities(value),
-          compact=False,
-          verbose=False,
-          python_format=True,
-      )

langfun/core/structured/prompting_test.py

@@ -41,13 +41,17 @@ class QueryTest(unittest.TestCase):
       self,
       prompt,
       schema,
+      examples: list[mapping.MappingExample] | None = None,
       *,
       expected_snippet: str,
       exact_match: bool = False,
       expected_modalities: int = 0,
       **kwargs,
   ):
-    m = prompting.query(prompt, schema=schema, **kwargs, returns_message=True)
+    m = prompting.query(
+        prompt, schema=schema, examples=examples,
+        **kwargs, returns_message=True
+    )
     self.assertIsNotNone(m.lm_input)
     if exact_match:
       self.assertEqual(expected_snippet, m.lm_input.text)
@@ -265,24 +269,60 @@ class QueryTest(unittest.TestCase):
             INPUT_OBJECT:
               ```python
               [
-                ModalityRef(
-                  name='input[0]'
-                ),
-                ModalityRef(
-                  name='input[1]'
-                )
+                <<[[input[0]]]>>,
+                <<[[input[1]]]>>
               ]
               ```
-
-            MODALITY_REFERENCES:
-              {
-                'input[0]': <<[[input[0]]]>>,
-                'input[1]': <<[[input[1]]]>>
-              }
             """),
         expected_modalities=2,
     )
 
+  def test_structure_with_modality_and_examples_to_structure_render(self):
+    lm = fake.StaticResponse('["cat", "mouse"]')
+    self.assert_render(
+        [
+            modalities.Image.from_bytes(b'cat_image'),
+            modalities.Image.from_bytes(b'mouse_image'),
+        ],
+        list[str],
+        examples=[
+            mapping.MappingExample(
+                input=[modalities.Image.from_bytes(b'dog_image')],
+                schema=list[str],
+                output=['dog'],
+            ),
+        ],
+        lm=lm,
+        expected_snippet=inspect.cleandoc("""
+            INPUT_OBJECT:
+              ```python
+              [
+                <<[[examples[0].input[0]]]>>
+              ]
+              ```
+
+            OUTPUT_TYPE:
+              list[str]
+
+            OUTPUT_OBJECT:
+              ```python
+              [
+                'dog'
+              ]
+              ```
+
+
+            INPUT_OBJECT:
+              ```python
+              [
+                <<[[input[0]]]>>,
+                <<[[input[1]]]>>
+              ]
+              ```
+            """),
+        expected_modalities=3,
+    )
+
   def test_bad_protocol(self):
     with self.assertRaisesRegex(ValueError, 'Unknown protocol'):
       prompting.query('what is 1 + 1', int, protocol='text')

langfun/core/structured/schema.py

@@ -656,6 +656,8 @@ class ValuePythonRepr(ValueRepr):
         return object_code
       else:
         object_code = SchemaPythonRepr().result_definition(cls_schema)
+    elif isinstance(value, lf.Template):
+      return str(value)
     else:
       object_code = pg.format(
           value, compact=compact, verbose=verbose, python_format=True

langfun/core/structured/schema_test.py

@@ -18,6 +18,7 @@ import inspect
 import typing
 import unittest
 
+import langfun.core as lf
 from langfun.core.llms import fake
 from langfun.core.structured import schema as schema_lib
 import pyglove as pg
@@ -694,6 +695,10 @@ class ValuePythonReprTest(unittest.TestCase):
         schema_lib.ValuePythonRepr().repr(1, schema_lib.Schema(int)),
         '```python\n1\n```'
     )
+    self.assertEqual(
+        schema_lib.ValuePythonRepr().repr(lf.Template('hi, {{a}}', a='foo')),
+        'hi, foo'
+    )
     self.assertEqual(
         schema_lib.ValuePythonRepr().repr(
             A([Foo(1), Foo(2)], 'bar'), schema_lib.Schema(A), markdown=False,

{langfun-0.0.2.dev20240608.dist-info → langfun-0.0.2.dev20240613.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240608
+Version: 0.0.2.dev20240613
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.0.2.dev20240608.dist-info → langfun-0.0.2.dev20240613.dist-info}/RECORD

@@ -1,5 +1,5 @@
 langfun/__init__.py,sha256=P62MnqA6-f0h8iYfQ3MT6Yg7a4qRnQeb4GrIn6dcSnY,2274
-langfun/core/__init__.py,sha256=nFQgTyhNLA83b_V_nPNByyO2JlF576AdS61AfA0SaN8,4728
+langfun/core/__init__.py,sha256=Mdp1a2YnXdSmfTfbUwuAnEWYbjA3rXXGtbxl5fljZyg,4812
 langfun/core/component.py,sha256=Icyoj9ICoJoK2r2PHbrFXbxnseOr9QZZOvKWklLWNo8,10276
 langfun/core/component_test.py,sha256=q15Xn51cVTu2RKxZ9U5VQgT3bm6RQ4638bKhWBtvW5o,8220
 langfun/core/concurrent.py,sha256=TRc49pJ3HQro2kb5FtcWkHjhBm8UcgE8RJybU5cU3-0,24537
@@ -19,6 +19,8 @@ langfun/core/modality.py,sha256=Tla4t86DUYHpbZ2G7dy1r19fTj_Ga5XOvlYp6lbWa-Q,3512
 langfun/core/modality_test.py,sha256=HyZ5xONKQ0Fw18SzoWAq-Ob9njOXIIjBo1hNtw-rudw,2400
 langfun/core/natural_language.py,sha256=3ynSnaYQnjE60LIPK5fyMgdIjubnPYZwzGq4rWPeloE,1177
 langfun/core/natural_language_test.py,sha256=LHGU_1ytbkGuSZQFIFP7vP3dBlcY4-A12fT6dbjUA0E,1424
+langfun/core/repr_utils.py,sha256=HrN7FoGUvpTlv5aL_XISouwZN84z9LmrB6_2jEn1ukc,2590
+langfun/core/repr_utils_test.py,sha256=-XId1A72Vbzo289dYuxC6TegNXuZhI28WbNrm1ghiwc,2206
 langfun/core/sampling.py,sha256=vygWvgC8MFw0_AKNSmz-ywMXJYWf8cl0tI8QycvAmyI,5795
 langfun/core/sampling_test.py,sha256=U7PANpMsl9E_pa4_Y4FzesSjcwg-u-LKHGCWSgv-8FY,3663
 langfun/core/subscription.py,sha256=euawEuSZP-BHydaT-AQpfYFL0m5pWPGcW0upFhrojqc,10930
@@ -79,8 +81,8 @@ langfun/core/modalities/audio.py,sha256=Qxo7bYjLKQ1gVJVomr9RqR2SvxY826QgXhTzzk43
 langfun/core/modalities/audio_test.py,sha256=gWCB9h3FyrdGqro3ajBXqkw0lU0W1sBjOOq6wZbl7Fg,2027
 langfun/core/modalities/image.py,sha256=qi7B9uYLxBoKvMzApdOQNpVcp_dKaRwLzeshg2nvo9k,926
 langfun/core/modalities/image_test.py,sha256=qU7G4ucUihIQ9ZB453FsUfcOipUYx5TnnuoMB1GIMfE,3034
-langfun/core/modalities/mime.py,sha256=yMpbBAhf7MmEPJm9qj7tTn7_XionZQ4XkgTT8StA7io,5836
-langfun/core/modalities/mime_test.py,sha256=ruEro7Joima2r-zOuQfO0NzBvmaweSQ6F6jsf-w4Bns,2468
+langfun/core/modalities/mime.py,sha256=7oYvwYZHb3uhjiL2rF6kvQWsWufY0UXl72wfDXC59ys,5918
+langfun/core/modalities/mime_test.py,sha256=kmRiPP-3Py02NnKPu0oPexSIJ-MXaaE2UYY82ga0TV8,2913
 langfun/core/modalities/ms_office.py,sha256=jOidMSdWCaV9RILpGz8VJkpTSpHJNoirD53jzQvcytM,3388
 langfun/core/modalities/ms_office_test.py,sha256=d_NZ0QU23NydenYZgNj6YxgO5ZYzjg-HCbglsVJGp04,87866
 langfun/core/modalities/pdf.py,sha256=mfaeCbUA4JslFVTARiJh8hW7imvL4tLVw9gUhO5bAZA,727
@@ -88,22 +90,22 @@ langfun/core/modalities/pdf_test.py,sha256=KE40zJD3Whe6ty2OULkp1J8jwLmB4ZjGXlGek
 langfun/core/modalities/video.py,sha256=sKcXxbx9S1ERjH8yEzkbtySpcRJD40QiPIQiIBy-U5I,955
 langfun/core/modalities/video_test.py,sha256=GbsoefSeO7y8kCYhTtp4s9E3ah_eYrb6Z-MXpS01RFc,2046
 langfun/core/structured/__init__.py,sha256=yp60yeDSVlyT0ElmLwbpBHnQtk_JX5udnjG1UGcsXKA,3776
-langfun/core/structured/completion.py,sha256=RzWdHyaqKj-tj6mGwpHXk0s8YbM0UEHSpyT2axmj-o8,7343
+langfun/core/structured/completion.py,sha256=cS2PjG7sqzDu5x0xoTk8RmNcoeX55iVwH38NTefkMHg,8108
 langfun/core/structured/completion_test.py,sha256=2mUzDMKGF_WGfTtsnfmfMDx97dkJ-98y8leen__qWLA,19281
 langfun/core/structured/description.py,sha256=SXW4MJvshFjbR-0gw6rE21o6WXq12UlRXawvDBXMZFA,5211
 langfun/core/structured/description_test.py,sha256=UtZGjSFUaQ6130t1E5tcL7ODu0xIefkapb53TbnqsK8,7362
 langfun/core/structured/function_generation.py,sha256=pFgS3vcRAWiuFBol2x5Eeip3XqoudONsOpeJpWyjT3s,7479
 langfun/core/structured/function_generation_test.py,sha256=ZJI-aaGgWWszn92u7h5IZ9Pl70N2DgAGGJrIxPzsvwg,10065
-langfun/core/structured/mapping.py,sha256=Vq3bQZWi4iYjcVn8D2kvPXTAm9jrQ-_1ueHLbXtGRNQ,12112
+langfun/core/structured/mapping.py,sha256=QKbSnvOgut-sx2mZPjHJcdlDLxR8b3ZC16ZLWociwog,11298
 langfun/core/structured/mapping_test.py,sha256=PiXklMeIa8L6KtMi3ju7J9Y39gZy0hIGz-Oeq4A_7XE,3835
 langfun/core/structured/parsing.py,sha256=keoVqEfzAbdULh6GawWFsTQzU91MzJXYFZjXGXLaD8g,11492
 langfun/core/structured/parsing_test.py,sha256=34wDrXaQ-EYhJLfDL8mX9K53oQMSzh5pVYdKjnESmK8,20895
 langfun/core/structured/prompting.py,sha256=vjmJn7GMFkqkrEB6qRrYvjB78WVx_OhsIyMN8PTb-7o,8641
-langfun/core/structured/prompting_test.py,sha256=8orqsTVDpDb_7oFZtGHtV_zRU_j_9RaOGH1QR8IurIU,21756
-langfun/core/structured/schema.py,sha256=7s6g9HSGogdWXnsX3_Pd8w8Cf1tKeFGtbNwxIG6l7lA,27664
+langfun/core/structured/prompting_test.py,sha256=W1FmbOfMXhBV8uZ3WN1fBxKLtdYngvR9l1JYo46HqJQ,22723
+langfun/core/structured/schema.py,sha256=oiT4P4Q9pG-QOnFzxETN2EQZqNln8nG4zAJHxcmeX9U,27729
 langfun/core/structured/schema_generation.py,sha256=U3nRQsqmMZg_qIVDh2fiY3K4JLfsAL1LcKzIFP1iXFg,5316
 langfun/core/structured/schema_generation_test.py,sha256=RM9s71kMNg2jTePwInkiW9fK1ACN37eyPeF8OII-0zw,2950
-langfun/core/structured/schema_test.py,sha256=P1Bm-khjbAebW6IDjop5dv1ddRD4pqL83FdK1VmfZPw,25108
+langfun/core/structured/schema_test.py,sha256=RjYhwTgktQgyqAjzLvo967nTiIK9KWgP-aNGg4e7ihE,25258
 langfun/core/structured/scoring.py,sha256=QyT1S8FkLtKICfUbh4AXoKK3YJ_rgejyk6TI2OtOa68,2751
 langfun/core/structured/scoring_test.py,sha256=39_dw6p_FkoqeUccO67yIqos-MccAWezoozS21i8mi0,1732
 langfun/core/templates/__init__.py,sha256=bO0eMsVJbi7sxEB2YlInKRQ2EVP-RyyKUwcD-8msuN4,927
@@ -115,8 +117,8 @@ langfun/core/templates/demonstration.py,sha256=vCrgYubdZM5Umqcgp8NUVGXgr4P_c-fik
 langfun/core/templates/demonstration_test.py,sha256=SafcDQ0WgI7pw05EmPI2S4v1t3ABKzup8jReCljHeK4,2162
 langfun/core/templates/selfplay.py,sha256=yhgrJbiYwq47TgzThmHrDQTF4nDrTI09CWGhuQPNv-s,2273
 langfun/core/templates/selfplay_test.py,sha256=rBW2Qr8yi-aWYwoTwRR-n1peKyMX9QXPZXURjLgoiRs,2264
-langfun-0.0.2.dev20240608.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.0.2.dev20240608.dist-info/METADATA,sha256=HhaObQS5WL8Y2uRuwNX389KbnRiRPsV3Vl-XzVGTN0A,3550
-langfun-0.0.2.dev20240608.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-langfun-0.0.2.dev20240608.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.0.2.dev20240608.dist-info/RECORD,,
+langfun-0.0.2.dev20240613.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.0.2.dev20240613.dist-info/METADATA,sha256=h3fWeJU8ejsvol_8wbw4DoS_D8L7ARomUo2hweGPF2A,3550
+langfun-0.0.2.dev20240613.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+langfun-0.0.2.dev20240613.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.0.2.dev20240613.dist-info/RECORD,,