langfun 0.0.2.dev20240215__py3-none-any.whl → 0.0.2.dev20240217__py3-none-any.whl

langfun/__init__.py

@@ -30,6 +30,7 @@ parse = structured.parse
 query = structured.query
 describe = structured.describe
 complete = structured.complete
+score = structured.score
 
 from langfun.core import eval  # pylint: disable=redefined-builtin
 from langfun.core import templates

langfun/core/__init__.py

@@ -100,6 +100,7 @@ from langfun.core.language_model import LanguageModel
 from langfun.core.language_model import LMSample
 from langfun.core.language_model import LMSamplingOptions
 from langfun.core.language_model import LMSamplingResult
+from langfun.core.language_model import LMScoringResult
 from langfun.core.language_model import LMCache
 from langfun.core.language_model import LMDebugMode
 

langfun/core/langfunc.py

@@ -210,6 +210,7 @@ class LangFunc(
       lm: language_model.LanguageModel | None = None,
       lm_input: message_lib.Message | None = None,
       cache_seed: int | None = 0,
+      skip_lm: bool = False,
       **variables,
   ) -> message_lib.Message:
     """Calls language model with `lm_input` or rendered text.
@@ -223,6 +224,8 @@ class LangFunc(
       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.
+      skip_lm: If True, returns the rendered prompt as a UserMessage object.
+        otherwise return the LLM response based on the rendered prompt.
       **variables: Template variables applicable to this or child LangFunc.
 
     Returns:
@@ -232,6 +235,7 @@ class LangFunc(
         lm=lm,
         lm_input=lm_input,
         cache_seed=cache_seed,
+        skip_lm=skip_lm,
         **variables,
     )
 
@@ -241,6 +245,7 @@ class LangFunc(
       lm: language_model.LanguageModel | None = None,
       lm_input: message_lib.Message | None = None,
       cache_seed: int | None = 0,
+      skip_lm: bool = False,
       **variables,
   ) -> message_lib.Message:
     """Call the language model once, with invoking the output transform."""
@@ -256,10 +261,13 @@ class LangFunc(
         if lm_input is None:
           lm_input = self.render(**kwargs)
 
+        lm_input.tag(message_lib.Message.TAG_LM_INPUT)
+        if skip_lm:
+          return lm_input
+
         self._cached_lm_input = lm_input
 
         # Send rendered text to LM.
-        lm_input.tag(message_lib.Message.TAG_LM_INPUT)
         lm_output = self.lm(lm_input, cache_seed=cache_seed)
 
         # Track the input as the source of the output.

langfun/core/langfunc_test.py

@@ -194,6 +194,11 @@ class LangFuncCallTest(unittest.TestCase):
       self.assertEqual(l(x=1, cache_seed=None), 'd')
       self.assertEqual(l(x=2), 'b')
 
+  def test_call_with_skip_lm(self):
+    l = LangFunc('hi')
+    with component.context(lm=ExcitedEchoer()):
+      self.assertEqual(l(skip_lm=True), 'hi')
+
 
 class CallEventTest(unittest.TestCase):
 

langfun/core/language_model.py

@@ -127,6 +127,15 @@ class LMSamplingOptions(component.Component):
     )
 
 
+class LMScoringResult(pg.Object):
+  """Language model scoring result."""
+
+  score: Annotated[
+      float,
+      'The log likelyhood of the requested completion towards the prompt.',
+  ]
+
+
 class LMCache(pg.Object):
   """Interface for LM cache."""
 
@@ -425,3 +434,83 @@ class LanguageModel(component.Component):
         title=f'\n[{call_counter}] LM RESPONSE (in {elapse:.2f} seconds):',
         color='blue',
     )
+
+  def score(
+      self,
+      prompt: str | message_lib.Message,
+      completions: list[str | message_lib.Message],
+      **kwargs,
+  ) -> list[LMScoringResult]:
+    """Scores the given prompt."""
+    prompt = message_lib.UserMessage.from_value(prompt)
+    completions = [message_lib.UserMessage.from_value(c) for c in completions]
+
+    call_counter = self._call_counter
+    self._call_counter += 1
+    request_start = time.time()
+
+    with component.context(override_attrs=True, **kwargs):
+      scoring_results = self._score(prompt, completions)
+      elapse = time.time() - request_start
+      self._debug_score(
+          prompt, completions, scoring_results, call_counter, elapse
+      )
+      return scoring_results
+
+  def _score(
+      self, prompt: message_lib.Message, completions: list[message_lib.Message]
+  ) -> list[LMScoringResult]:
+    """Subclass to implement."""
+    raise NotImplementedError(
+        f'{self.__class__.__name__} does not support scoring.'
+    )
+
+  def _debug_score(
+      self,
+      prompt: message_lib.Message,
+      completions: list[message_lib.Message],
+      scoring_results: list[LMScoringResult],
+      call_counter: int,
+      elapse: float,
+  ):
+    debug = self.debug
+    if isinstance(debug, bool):
+      debug = LMDebugMode.ALL if debug else LMDebugMode.NONE
+
+    if debug & LMDebugMode.INFO:
+      self._debug_model_info(call_counter)
+
+    if debug & LMDebugMode.PROMPT:
+      console.write(
+          prompt,
+          title=f'\n[{call_counter}] SCORING LM WITH PROMPT:',
+          color='green',
+      )
+      referred_modalities = prompt.referred_modalities()
+      if referred_modalities:
+        console.write(
+            pg.object_utils.kvlist_str(
+                [(k, repr(v), None) for k, v in referred_modalities.items()]
+            ),
+            title=f'\n[{call_counter}] MODALITY OBJECTS SENT TO LM:',
+            color='green',
+        )
+
+    if debug & LMDebugMode.RESPONSE:
+      console.write(
+          '',
+          title=(
+              f'\n[{call_counter}] SCORING COMPLETED (in {elapse:.2f} seconds):'
+          ),
+          color='blue',
+      )
+      for i, (c, r) in enumerate(zip(completions, scoring_results)):
+        console.write(
+            c,
+            title=f'COMPLETION #{i}',
+            color='green',
+        )
+        console.write(
+            f'score: {r.score}',
+            color='blue',
+        )

langfun/core/language_model_test.py

@@ -54,6 +54,19 @@ class MockModel(lm_lib.LanguageModel):
     )(prompts)
 
 
+class MockScoringModel(MockModel):
+
+  def _score(
+      self,
+      prompt: message_lib.Message,
+      completions: list[message_lib.Message],
+      **kwargs
+  ) -> list[lm_lib.LMScoringResult]:
+    return [
+        lm_lib.LMScoringResult(score=-i * 1.0) for i in range(len(completions))
+    ]
+
+
 class LMSamplingOptionsTest(unittest.TestCase):
   """Tests for LMSamplingOptions."""
 
@@ -266,6 +279,68 @@ class LanguageModelTest(unittest.TestCase):
       for expected_exclude in expected_excluded:
         self.assertNotIn('[0] ' + expected_exclude, debug_info)
 
+  def test_score(self):
+    info_flag = lm_lib.LMDebugMode.INFO
+    prompt_flag = lm_lib.LMDebugMode.PROMPT
+    response_flag = lm_lib.LMDebugMode.RESPONSE
+    debug_prints = {
+        info_flag: 'LM INFO',
+        prompt_flag: 'SCORING LM WITH PROMPT',
+        response_flag: 'SCORING COMPLETED',
+    }
+    debug_modes = [
+        info_flag,
+        prompt_flag,
+        response_flag,
+        info_flag | prompt_flag,
+        info_flag | response_flag,
+        prompt_flag | response_flag,
+        info_flag | prompt_flag | response_flag,
+    ]
+
+    class Image(modality.Modality):
+      def to_bytes(self):
+        return b'fake_image'
+
+    for debug_mode in debug_modes:
+      string_io = io.StringIO()
+      lm = MockScoringModel()
+
+      with contextlib.redirect_stdout(string_io):
+        self.assertEqual(
+            lm.score(
+                message_lib.UserMessage('hi {{image}}', image=Image()),
+                ['1', '2'], debug=debug_mode),
+            [
+                lm_lib.LMScoringResult(score=-0.0),
+                lm_lib.LMScoringResult(score=-1.0),
+            ],
+        )
+
+      debug_info = string_io.getvalue()
+      expected_included = [
+          debug_prints[f]
+          for f in lm_lib.LMDebugMode
+          if f != lm_lib.LMDebugMode.NONE and f in debug_mode
+      ]
+      expected_excluded = [
+          debug_prints[f]
+          for f in lm_lib.LMDebugMode
+          if f != lm_lib.LMDebugMode.NONE and f not in debug_mode
+      ]
+
+      for expected_include in expected_included:
+        self.assertIn('[0] ' + expected_include, debug_info)
+      for expected_exclude in expected_excluded:
+        self.assertNotIn('[0] ' + expected_exclude, debug_info)
+
+      if debug_mode & lm_lib.LMDebugMode.PROMPT:
+        self.assertIn('[0] MODALITY OBJECTS SENT TO LM', debug_info)
+
+  def test_score_with_unsupported_model(self):
+    with self.assertRaises(NotImplementedError):
+      MockModel().score('hi', ['1', '2'])
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/llms/__init__.py

@@ -18,6 +18,7 @@
 # pylint: disable=g-import-not-at-top
 
 # LMs for testing.
+from langfun.core.llms.fake import Fake
 from langfun.core.llms.fake import Echo
 from langfun.core.llms.fake import StaticMapping
 from langfun.core.llms.fake import StaticResponse

langfun/core/llms/fake.py

@@ -17,7 +17,14 @@ from typing import Annotated
 import langfun.core as lf
 
 
-class Echo(lf.LanguageModel):
+class Fake(lf.LanguageModel):
+  """The base class for all fake language models."""
+
+  def _score(self, prompt: lf.Message, completions: list[lf.Message]):
+    return [lf.LMScoringResult(score=-i * 1.0) for i in range(len(completions))]
+
+
+class Echo(Fake):
   """A simple echo language model for testing."""
 
   def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
@@ -28,7 +35,7 @@ class Echo(lf.LanguageModel):
 
 
 @lf.use_init_args(['response'])
-class StaticResponse(lf.LanguageModel):
+class StaticResponse(Fake):
   """Language model that always gives the same canned response."""
 
   response: Annotated[
@@ -44,7 +51,7 @@ class StaticResponse(lf.LanguageModel):
 
 
 @lf.use_init_args(['mapping'])
-class StaticMapping(lf.LanguageModel):
+class StaticMapping(Fake):
   """A static mapping from prompt to response."""
 
   mapping: Annotated[
@@ -60,7 +67,7 @@ class StaticMapping(lf.LanguageModel):
 
 
 @lf.use_init_args(['sequence'])
-class StaticSequence(lf.LanguageModel):
+class StaticSequence(Fake):
   """A static sequence of responses to use."""
 
   sequence: Annotated[

langfun/core/llms/fake_test.py

@@ -38,6 +38,13 @@ class EchoTest(unittest.TestCase):
     self.assertIn('[0] PROMPT SENT TO LM:', debug_info)
     self.assertIn('[0] LM RESPONSE', debug_info)
 
+  def test_score(self):
+    lm = fakelm.Echo()
+    self.assertEqual(
+        lm.score('hi', ['hello', 'how are you']),
+        [lf.LMScoringResult(0.0), lf.LMScoringResult(-1.0)],
+    )
+
 
 class StaticResponseTest(unittest.TestCase):
 

langfun/core/structured/__init__.py

@@ -64,6 +64,8 @@ from langfun.core.structured.description import describe
 from langfun.core.structured.completion import CompleteStructure
 from langfun.core.structured.completion import complete
 
+from langfun.core.structured.scoring import score
+
 # Expose default examples for structured operations so users could refer to
 # them.
 from langfun.core.structured.parsing import DEFAULT_PARSE_EXAMPLES

langfun/core/structured/completion.py

@@ -153,6 +153,7 @@ def complete(
     *,
     lm: lf.LanguageModel | None = None,
     examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
     autofix: int = 0,
     autofix_lm: lf.LanguageModel | None = None,
     returns_message: bool = False,
@@ -197,6 +198,9 @@ def complete(
       `lf.context` context manager will be used.
     examples: An optional list of fewshot examples for helping parsing. If None,
       the default one-shot example will be added.
+    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.
     autofix: Number of attempts to auto fix the generated code. If 0, autofix is
       disabled.
     autofix_lm: The language model to use for autofix. If not specified, the
@@ -218,5 +222,5 @@ def complete(
       **kwargs,
   )
 
-  output = t(lm=lm, autofix_lm=autofix_lm or lm)
+  output = t(lm=lm, cache_seed=cache_seed, autofix_lm=autofix_lm or lm)
   return output if returns_message else output.result

langfun/core/structured/description.py

@@ -44,6 +44,7 @@ def describe(
     *,
     lm: lf.LanguageModel | None = None,
     examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
     **kwargs,
 ) -> str:
   """Describes a structured value using natural language.
@@ -97,6 +98,9 @@ def describe(
       `lf.context` context manager will be used.
     examples: An optional list of fewshot examples for helping parsing. If None,
       the default one-shot example will be added.
+    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.
     **kwargs: Keyword arguments passed to the `lf.structured.DescribeStructure`.
 
   Returns:
@@ -106,7 +110,7 @@ def describe(
     examples = DEFAULT_DESCRIBE_EXAMPLES
   return DescribeStructure(
       input=value, context=context, examples=examples, **kwargs
-  )(lm=lm).text
+  )(lm=lm, cache_seed=cache_seed).text
 
 
 class _Country(pg.Object):

langfun/core/structured/parsing.py

@@ -79,6 +79,7 @@ def parse(
     lm: lf.LanguageModel | None = None,
     examples: list[mapping.MappingExample] | None = None,
     include_context: bool = False,
+    cache_seed: int | None = 0,
     autofix: int = 0,
     autofix_lm: lf.LanguageModel | None = None,
     protocol: schema_lib.SchemaProtocol = 'python',
@@ -134,6 +135,9 @@ def parse(
       the default one-shot example will be added.
     include_context: If True, include the request sent to LLM for obtaining the
       response to pares. Otherwise include only the response.
+    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.
     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
@@ -166,7 +170,7 @@ def parse(
   )
 
   # Setting up context.
-  call_context = dict(autofix=autofix)
+  call_context = dict(cache_seed=cache_seed, autofix=autofix)
   if lm is not None:
     call_context['lm'] = lm
   autofix_lm = autofix_lm or lm
@@ -188,6 +192,7 @@ def call(
     parsing_lm: lf.LanguageModel | None = None,
     parsing_examples: list[mapping.MappingExample] | None = None,
     parsing_include_context: bool = False,
+    cache_seed: int | None = 0,
     autofix: int = 0,
     autofix_lm: lf.LanguageModel | None = None,
     response_postprocess: Callable[[str], str] | None = None,
@@ -231,6 +236,9 @@ def call(
       `lf.structured.DEFAULT_PARSE_EXAMPLES` will be used.
     parsing_include_context: If True, include the request sent to LLM for
       obtaining the response to pares. Otherwise include only the response.
+    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.
     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
@@ -253,7 +261,10 @@ def call(
   lm_output = lf.LangFunc.from_value(prompt, **kwargs)(lm=lm)
 
   if response_postprocess is not None:
-    lm_output.set('text', response_postprocess(lm_output.text))
+    postprocessed_text = response_postprocess(lm_output.text)
+    if postprocessed_text != lm_output.text:
+      processed_lm_output = lf.AIMessage(postprocessed_text, source=lm_output)
+      lm_output = processed_lm_output
 
   if schema in (str, None):
     return lm_output if returns_message else lm_output.text
@@ -265,6 +276,7 @@ def call(
       examples=parsing_examples,
       lm=parsing_lm or lm,
       include_context=parsing_include_context,
+      cache_seed=cache_seed,
       autofix=autofix,
       autofix_lm=autofix_lm or lm,
       protocol=protocol,

langfun/core/structured/prompting.py

@@ -106,10 +106,12 @@ def query(
     *,
     lm: lf.LanguageModel | None = None,
     examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
     autofix: int = 0,
     autofix_lm: lf.LanguageModel | None = None,
     protocol: schema_lib.SchemaProtocol = 'python',
     returns_message: bool = False,
+    skip_lm: bool = False,
     **kwargs,
 ) -> Any:
   """Parse a natural langugage message based on schema.
@@ -154,6 +156,9 @@ def query(
       `lf.context` context manager will be used.
     examples: An optional list of fewshot examples for helping parsing. If None,
       the default one-shot example will be added.
+    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.
     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
@@ -163,6 +168,8 @@ def query(
       are 'json' and 'python'. By default `python` will be used.
     returns_message: If True, returns `lf.Message` as the output, instead of
       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.
 
@@ -178,7 +185,9 @@ def query(
 
   if schema in (None, str):
     # Query with natural language output.
-    output = lf.LangFunc.from_value(prompt, **kwargs)(lm=lm)
+    output = lf.LangFunc.from_value(prompt, **kwargs)(
+        lm=lm, cache_seed=cache_seed, skip_lm=skip_lm
+    )
     return output if returns_message else output.text
 
   # Query with structured output.
@@ -202,5 +211,7 @@ def query(
   )(
       lm=lm,
       autofix_lm=autofix_lm or lm,
+      cache_seed=cache_seed,
+      skip_lm=skip_lm,
   )
   return output if returns_message else output.result

langfun/core/structured/prompting_test.py

@@ -235,6 +235,10 @@ class QueryTest(unittest.TestCase):
         expected_modalities=2,
     )
 
+  def test_bad_protocol(self):
+    with self.assertRaisesRegex(ValueError, 'Unknown protocol'):
+      prompting.query('what is 1 + 1', int, protocol='text')
+
 
 class QueryStructurePythonTest(unittest.TestCase):
 

langfun/core/structured/scoring.py

@@ -0,0 +1,75 @@
+# Copyright 2023 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.
+"""Scoring the output objects based on their inputs."""
+
+from typing import Any, Type, Union
+
+import langfun.core as lf
+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
+
+
+def score(
+    prompt: Union[str, pg.Symbolic],
+    completions: list[str | pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    **kwargs,
+) -> list[float]:
+  """Scores the outputs based on the prompt."""
+  if not completions:
+    raise ValueError('`completions` must not be empty.')
+
+  if schema is None:
+    for c in completions:
+      if schema is None:
+        schema = type(c)
+      elif schema is not type(c):
+        raise ValueError(
+            '`schema` cannot be inferred from completions of different types: '
+            f'{[type(c) for c in completions]}.'
+        )
+
+  input_message = prompting.query(
+      prompt,
+      schema,
+      examples=examples,
+      protocol=protocol,
+      skip_lm=True,
+      returns_message=True,
+      **kwargs,
+  )
+  if lm is None:
+    lm_override = lf.get_contextual_override('lm')
+    if lm_override is None:
+      raise ValueError('`lm` must be specified or provided from `lf.context`.')
+    lm = lm_override.value
+
+  results = lm.score(
+      input_message,
+      [
+          mapping.MappingExample.value_repr(
+              c, protocol=protocol, compact=False, verbose=False
+          )
+          for c in completions
+      ],
+  )
+  return [r.score for r in results]

langfun/core/structured/scoring_test.py

@@ -0,0 +1,44 @@
+# Copyright 2023 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.
+
+import unittest
+import langfun.core as lf
+from langfun.core.llms import fake
+from langfun.core.structured import scoring
+
+
+class ScoringTest(unittest.TestCase):
+
+  def test_bad_call(self):
+    with self.assertRaisesRegex(ValueError, '`completions` must not be empty'):
+      scoring.score('hi', [])
+
+    with self.assertRaisesRegex(
+        ValueError, '`schema` cannot be inferred from completions'
+    ):
+      scoring.score('hi', [1, 'b'])
+
+    with self.assertRaisesRegex(ValueError, '`lm` must be specified'):
+      scoring.score('hi', [1, 2])
+
+  def test_score(self):
+    self.assertEqual(scoring.score('hi', [1, 2], lm=fake.Echo()), [0.0, -1.0])
+
+  def test_scope_with_lm_from_the_context(self):
+    with lf.context(lm=fake.Echo()):
+      self.assertEqual(scoring.score('hi', [1, 2]), [0.0, -1.0])
+
+
+if __name__ == '__main__':
+  unittest.main()

{langfun-0.0.2.dev20240215.dist-info → langfun-0.0.2.dev20240217.dist-info}/METADATA

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

{langfun-0.0.2.dev20240215.dist-info → langfun-0.0.2.dev20240217.dist-info}/RECORD

@@ -1,15 +1,15 @@
-langfun/__init__.py,sha256=2HUBxiByAEu63XqaF89hQfI4sqFG1qGffua-JPy4XIY,1689
-langfun/core/__init__.py,sha256=dl7itWvZUEvqDeK2EWd-9lGlZu8cLXCO45HcaZKWAo4,4136
+langfun/__init__.py,sha256=8o5FY1mvt8gErV_AEyBBgQJxEC1cQnfXAvDphMvvS78,1714
+langfun/core/__init__.py,sha256=sVcPl89lWYHQ1cUoaLaM8dErCovugJo5e2F3A_94Q3Y,4192
 langfun/core/component.py,sha256=VRPfDB_2jEnxcB3-HoiVjG4ID-SMenNPIsytb0uXMPg,9674
 langfun/core/component_test.py,sha256=VAPd6V_-odAe8rBvesW3ogYDd6OSqRq4FaPhfgOM4Zg,7949
 langfun/core/concurrent.py,sha256=HQJOseNZ-XZZR5VmC8lHoDNFzlkkCa_-ri7nOKJfV5s,24147
 langfun/core/concurrent_test.py,sha256=qQT6_Dq5NVz7qXFLzSf2Rhzkfkh07gocjHMBaT1nSeE,14928
 langfun/core/console.py,sha256=bk5rNPNm9rMGW5YT2HixxU04p2umnoabn5SDz6Dqe88,2317
 langfun/core/console_test.py,sha256=5SYJdxpJGLgdSSQqqMPoA1X6jpsLD8rgcyk-EgI65oE,1077
-langfun/core/langfunc.py,sha256=266xNz8Vgal7K4HSsrYt7z7_qPYV4bWWK626IbbohrE,11573
-langfun/core/langfunc_test.py,sha256=ukv5cnad5ZBckM2PhyIFq79BPN0Db4cszMrPqh_CZkA,8163
-langfun/core/language_model.py,sha256=JHIfW0GxFx1YVEM-drS_Iy4goFJt63LBosCM4CILWTY,12920
-langfun/core/language_model_test.py,sha256=gcW4OJJjB-V1b4kEF8zG91t36sVn3H0Yuj0LQxi83Ek,9122
+langfun/core/langfunc.py,sha256=WXdTc3QsmGD_n80KD9dFRr5MHpGZ9E_y_Rhtk4t9-3w,11852
+langfun/core/langfunc_test.py,sha256=8WeiyNauZPkbAA3HiLjVw5-pRSmiLlz-77lB_fjHGdA,8317
+langfun/core/language_model.py,sha256=Qbm7wxgxW26bCVwtgpp-4aV3BKYAsb4IJrJuzhf3Q6o,15507
+langfun/core/language_model_test.py,sha256=h5MWooOb9HubvOzxaBnH6WuDYBdxTetu7JZSWDzva3M,11368
 langfun/core/memory.py,sha256=f-asN1F7Vehgdn_fK84v73GrEUOxRtaW934keutTKjk,2416
 langfun/core/message.py,sha256=QhvV9t5qaryPcruyxxcXi3gm9QDInkSldwTtK6sVJ3c,15734
 langfun/core/message_test.py,sha256=Z23pUM5vPnDrYkIIibe2KL73D5HKur_awI0ut_EQFQA,9501
@@ -46,9 +46,9 @@ langfun/core/eval/matching.py,sha256=g2yuBb4FeOlAlB10hqdWvaIg4QVQlJbiViRDcD2Y8go
 langfun/core/eval/matching_test.py,sha256=IfuMF_dEmy4VzK6tIldRzD2Nqlml7SSh4u-baFNcZrw,4912
 langfun/core/eval/scoring.py,sha256=mshqbV_WM0zcp15TSR32ACMBDymlsbf6YH06PPx1Tw0,6139
 langfun/core/eval/scoring_test.py,sha256=_L_B40VZkyI2_PJce-jVKYC4llrO4jGUR5j86Gu6AT0,4046
-langfun/core/llms/__init__.py,sha256=zTTSz46M52wqJtgxg2lGvTgrTB1wl9xMaQvOxfi00bs,2346
-langfun/core/llms/fake.py,sha256=JH790_WDtlohL0leJMqd1F6a1YuM9XV3rgxHBsoILRg,2309
-langfun/core/llms/fake_test.py,sha256=nP3420LKGwTJJG1YH3y5XgH6yKmbFmmbonBwvMu-ZYA,3368
+langfun/core/llms/__init__.py,sha256=T4mgT091BLA4mHrOjAvEGhZPHf0tiYgqD88l_JTp1dQ,2386
+langfun/core/llms/fake.py,sha256=dVzOrW27RZ1p3DdQoRCRZs_vfoQcTcNrlWxia7oqmvw,2499
+langfun/core/llms/fake_test.py,sha256=Qk_Yoi4Z7P9o6f8Q_BZkaSlvxH89ZVsDxnVIbSBRBXk,3555
 langfun/core/llms/gemini.py,sha256=p3d4Cl2uET-os1n_V3YNE6-6cYrZjndj7lxZIk2E8_4,5688
 langfun/core/llms/gemini_test.py,sha256=ybNNCn3JW3hYpMe0wT5ILGDrMPaYYU8PN2kSookM0jk,5433
 langfun/core/llms/llama_cpp.py,sha256=EIjJa1-Tg4_VaIxVR88oDWSWc_axc1r2KwSPpl4PSp0,2549
@@ -65,19 +65,21 @@ langfun/core/memories/conversation_history_test.py,sha256=AaW8aNoFjxNusanwJDV0r3
 langfun/core/modalities/__init__.py,sha256=VI96XGNfXqcJpBh2c17tkTs0gpO5ftc77Ep0jfLOztw,882
 langfun/core/modalities/image.py,sha256=HU0sV4ZTwRnAwQthmdWZwhFZRD86RyvqoS8JUW2Ia-A,2065
 langfun/core/modalities/image_test.py,sha256=YxDRvC49Bjwyyndd_P7y6XjyS7dOft0Zewwxk-7q4kE,2301
-langfun/core/structured/__init__.py,sha256=tGH0MYr5vzK0H2DpYQ2bcW2C5bpPUaLzMk2W2Fj29M4,3136
-langfun/core/structured/completion.py,sha256=XERoxtYPXOTlPdZ2bp4i9R4jl3kA3SOeyLmuSqHG9AM,7036
+langfun/core/structured/__init__.py,sha256=LZ5BFLX6VXy1zH17yChWCdg8bvIDrhtL2lqtSCwtZ-M,3187
+langfun/core/structured/completion.py,sha256=skBxt6V_fv2TBUKnzFgnPMbVY8HSYn8sY04MLok2yvs,7299
 langfun/core/structured/completion_test.py,sha256=98UCgA4gzfp6H6HgP2s2kcKs25YH3k4Nxj1rgAvmVBw,19249
-langfun/core/structured/description.py,sha256=vDiW1g2VbvG8ucNjV7Pp3VYCeAnLcp6vLQ0MfURcZFk,4825
+langfun/core/structured/description.py,sha256=3MLTbpTpeiBqMRe3WfDNIxtrE6WQsKJsJdkbfcyPlsg,5088
 langfun/core/structured/description_test.py,sha256=UtZGjSFUaQ6130t1E5tcL7ODu0xIefkapb53TbnqsK8,7362
 langfun/core/structured/mapping.py,sha256=lGkjhmvVdhBGgJmc5KbfT2xQjC1MuU4OCcCfsAYJjaQ,10192
 langfun/core/structured/mapping_test.py,sha256=07DDCGbwytQHSMm7fCi5-Ly-JNgdV4ubHZq0wthX4A4,3338
-langfun/core/structured/parsing.py,sha256=XWo1UdG1A_c0v4OgQ1C_6nK0264_UAVrmJfFz4jHbRE,10690
+langfun/core/structured/parsing.py,sha256=YKWl9ZQ2uFkt78SXiRISWHg8_cDMGMwAN3SeK-OqWt4,11382
 langfun/core/structured/parsing_test.py,sha256=2_Uf3LYNRON1-5ysEr75xiG_cAxR3ZiixSfvUQu6mOQ,20846
-langfun/core/structured/prompting.py,sha256=P8in3qHXCuwjfzLpplS5woQSHV5aheXgm2mFiqVQD4g,6384
-langfun/core/structured/prompting_test.py,sha256=5lPsxUzyHEjOh0D5V5GEYjFFJZvUrebLV1aCCJS4H3Y,18971
+langfun/core/structured/prompting.py,sha256=0xRPC0K_RaFRv-j52x8_-1n1eRFSomJEpdZApVXsCV0,6902
+langfun/core/structured/prompting_test.py,sha256=SwoYbPyKhUT1H2QbqHvl93biCiE9Ttn1aWixoHH-v9Y,19129
 langfun/core/structured/schema.py,sha256=5DKba0LrvXCJFRY-NVfER3p54BLOB7M3Yi2-u5IAJTw,24115
 langfun/core/structured/schema_test.py,sha256=LEtCST5Bfwoke59I6Q1mnOJLf2cFXQwKwTeAkI2hgqM,20912
+langfun/core/structured/scoring.py,sha256=a3vfGnqf-DOWjD07MF54GCZTO_R1RTxTDVPzerXnU0s,2325
+langfun/core/structured/scoring_test.py,sha256=TznLMl0x9QxzmhHz_3Vr44VOXuvFnUSeRQVhu33W5cA,1437
 langfun/core/templates/__init__.py,sha256=bO0eMsVJbi7sxEB2YlInKRQ2EVP-RyyKUwcD-8msuN4,927
 langfun/core/templates/completion.py,sha256=mUqZHOEV3ag6-A08XghpeEltcrBvCDxXP004eDDfeag,1931
 langfun/core/templates/completion_test.py,sha256=vGnjnM38UHyVDUyaUYtmp20s9KBGOdbPVsX-H-ET11E,1636
@@ -87,8 +89,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=IB5rWbjK_9CTkqEo1BclQPzFAKcIiusJckH8J19HFgI,2096
-langfun-0.0.2.dev20240215.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.0.2.dev20240215.dist-info/METADATA,sha256=oo4UvDeNdxk0glqHLdwP2tjejbXpEBnPfquoi3kzuOg,3368
-langfun-0.0.2.dev20240215.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-langfun-0.0.2.dev20240215.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.0.2.dev20240215.dist-info/RECORD,,
+langfun-0.0.2.dev20240217.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.0.2.dev20240217.dist-info/METADATA,sha256=2D8wQbXh09hRN_TnmaxS2JeVLKKKqkbM9JDjqiBR7yg,3368
+langfun-0.0.2.dev20240217.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+langfun-0.0.2.dev20240217.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.0.2.dev20240217.dist-info/RECORD,,