langfun 0.0.2.dev20240507__py3-none-any.whl → 0.0.2.dev20240513__py3-none-any.whl

langfun/__init__.py

@@ -33,6 +33,11 @@ complete = structured.complete
 score = structured.score
 generate_class = structured.generate_class
 
+# Helper functions for input/output transformations based on
+# `lf.query` (e.g. jax-on-beam could use these for batch processing)
+query_prompt = structured.query_prompt
+query_output = structured.query_output
+
 source_form = structured.source_form
 function_gen = structured.function_gen
 

langfun/core/eval/base.py

@@ -1179,7 +1179,7 @@ class Evaluation(Evaluable):
 
   def process(self, example: Any, **kwargs) -> lf.Message:
     """Process an example and returns its output."""
-    prompt = self.prompt.render(example=example).text
+    prompt = lf.Template.from_value(self.prompt, example=example)
     if self.method == 'call':
       return lf_structured.call(
           prompt,
@@ -1207,7 +1207,9 @@ class Evaluation(Evaluable):
     else:
       assert self.method == 'complete', self.method
       assert isinstance(self.schema.spec, pg.typing.Object), self.schema
-      input_value = self.schema.spec.cls.partial(prompt)
+      # TODO(daiyip): Currently multi-modal inputs within the prompt for
+      # completion is not supported.
+      input_value = self.schema.spec.cls.partial(prompt.render().text)
       return lf_structured.complete(
           input_value,
           lm=self.lm,

langfun/core/langfunc.py

@@ -14,7 +14,7 @@
 """LangFunc: Language-based functions."""
 
 import dataclasses
-from typing import Annotated, Type, Union
+from typing import Annotated, Type
 
 from langfun.core import component
 from langfun.core import language_model
@@ -328,22 +328,6 @@ class LangFunc(
     """Transforms the output message before returning from __call__."""
     return lm_output
 
-  @classmethod
-  def from_value(
-      cls, value: Union[str, template_lib.Template], **kwargs
-  ) -> 'LangFunc':
-    """Create a LangFunc object from a string or template."""
-    if isinstance(value, LangFunc):
-      return value
-    if isinstance(value, template_lib.Template):
-      lfun = LangFunc(value.template_str, **kwargs)
-      # So lfun could acccess all attributes from value.
-      lfun.sym_setparent(value)
-      return lfun
-    if isinstance(value, str):
-      return LangFunc(template_str=value, **kwargs)
-    return LangFunc('{{input}}', input=value, **kwargs)
-
 
 # Register converter from str to LangFunc, therefore we can always
 # pass strs to attributes that accept LangFunc.

langfun/core/langfunc_test.py

@@ -57,6 +57,10 @@ class BasicTest(unittest.TestCase):
     l2 = LangFunc.from_value(l1)
     self.assertIs(l2, l1)
 
+    l3 = LangFunc.from_value(l1, x=1)
+    self.assertIsNot(l3, l1)
+    self.assertTrue(pg.eq(l3, LangFunc('Hello', x=1)))
+
     c = template_lib.Template(
         '{{x}} + {{l}}',
         x=1,

langfun/core/llms/__init__.py

@@ -27,6 +27,7 @@ from langfun.core.llms.fake import StaticSequence
 # Gemini models.
 from langfun.core.llms.google_genai import GenAI
 from langfun.core.llms.google_genai import GeminiPro
+from langfun.core.llms.google_genai import GeminiPro1_5
 from langfun.core.llms.google_genai import GeminiProVision
 from langfun.core.llms.google_genai import Palm2
 from langfun.core.llms.google_genai import Palm2_IT
@@ -73,6 +74,13 @@ from langfun.core.llms.groq import GroqLlama2_70B
 from langfun.core.llms.groq import GroqMistral_8x7B
 from langfun.core.llms.groq import GroqGemma7B_IT
 
+from langfun.core.llms.vertexai import VertexAI
+from langfun.core.llms.vertexai import VertexAIGeminiPro1_5
+from langfun.core.llms.vertexai import VertexAIGeminiPro1
+from langfun.core.llms.vertexai import VertexAIGeminiPro1Vision
+from langfun.core.llms.vertexai import VertexAIPalm2
+from langfun.core.llms.vertexai import VertexAIPalm2_32K
+
 
 # LLaMA C++ models.
 from langfun.core.llms.llama_cpp import LlamaCppRemote

langfun/core/llms/fake.py

@@ -57,12 +57,12 @@ class StaticResponse(Fake):
   """Language model that always gives the same canned response."""
 
   response: Annotated[
-      str,
+      str | lf.Message,
       'A canned response that will be returned regardless of the prompt.'
   ]
 
   def _response_from(self, prompt: lf.Message) -> lf.Message:
-    return lf.AIMessage(self.response)
+    return lf.AIMessage.from_value(self.response)
 
 
 @lf.use_init_args(['mapping'])
@@ -70,12 +70,12 @@ class StaticMapping(Fake):
   """A static mapping from prompt to response."""
 
   mapping: Annotated[
-      dict[str, str],
+      dict[str, str | lf.Message],
       'A mapping from prompt to response.'
   ]
 
   def _response_from(self, prompt: lf.Message) -> lf.Message:
-    return lf.AIMessage(self.mapping[prompt])
+    return lf.AIMessage.from_value(self.mapping[prompt])
 
 
 @lf.use_init_args(['sequence'])
@@ -83,7 +83,7 @@ class StaticSequence(Fake):
   """A static sequence of responses to use."""
 
   sequence: Annotated[
-      list[str],
+      list[str | lf.Message],
       'A sequence of strings as the response.'
   ]
 
@@ -92,6 +92,6 @@ class StaticSequence(Fake):
     self._pos = 0
 
   def _response_from(self, prompt: lf.Message) -> lf.Message:
-    r = lf.AIMessage(self.sequence[self._pos])
+    r = lf.AIMessage.from_value(self.sequence[self._pos])
     self._pos += 1
     return r

langfun/core/llms/google_genai.py

@@ -34,6 +34,7 @@ class GenAI(lf.LanguageModel):
           'gemini-pro-vision',
           'text-bison-001',
           'chat-bison-001',
+          'gemini-1.5-pro-latest',
       ],
       'Model name.',
   ]
@@ -262,6 +263,13 @@ _GOOGLE_GENAI_MODEL_HUB = _ModelHub()
 #
 
 
+class GeminiPro1_5(GenAI):  # pylint: disable=invalid-name
+  """Gemini Pro latest model."""
+
+  model = 'gemini-1.5-pro-latest'
+  multimodal = True
+
+
 class GeminiPro(GenAI):
   """Gemini Pro model."""
 

langfun/core/llms/openai.py

@@ -233,8 +233,9 @@ class OpenAI(lf.LanguageModel):
         for chunk in prompt.chunk():
           if isinstance(chunk, str):
             item = dict(type='text', text=chunk)
-          elif isinstance(chunk, lf_modalities.Image) and chunk.uri:
-            item = dict(type='image_url', image_url=dict(url=chunk.uri))
+          elif isinstance(chunk, lf_modalities.Image):
+            uri = chunk.uri or chunk.content_uri
+            item = dict(type='image_url', image_url=dict(url=uri))
           else:
             raise ValueError(f'Unsupported modality object: {chunk!r}.')
           content.append(item)

langfun/core/llms/vertexai.py

@@ -0,0 +1,291 @@
+# 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.
+"""Vertex AI generative models."""
+
+import functools
+import os
+from typing import Annotated, Any
+
+from google.auth import credentials as credentials_lib
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+import pyglove as pg
+
+
+SUPPORTED_MODELS_AND_SETTINGS = {
+    'gemini-1.5-pro-preview-0409': pg.Dict(api='gemini', rpm=5),
+    'gemini-1.0-pro': pg.Dict(api='gemini', rpm=300),
+    'gemini-1.0-pro-vision': pg.Dict(api='gemini', rpm=100),
+    # PaLM APIs.
+    'text-bison': pg.Dict(api='palm', rpm=1600),
+    'text-bison-32k': pg.Dict(api='palm', rpm=300),
+    'text-unicorn': pg.Dict(api='palm', rpm=100),
+}
+
+
+@lf.use_init_args(['model'])
+class VertexAI(lf.LanguageModel):
+  """Language model served on VertexAI."""
+
+  model: pg.typing.Annotated[
+      pg.typing.Enum(
+          pg.MISSING_VALUE, list(SUPPORTED_MODELS_AND_SETTINGS.keys())
+      ),
+      (
+          'Vertex AI model name. See '
+          'https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models '
+          'for details.'
+      ),
+  ]
+
+  project: Annotated[
+      str | None,
+      (
+          'Vertex AI project ID. Or set from environment variable '
+          'VERTEXAI_PROJECT.'
+      ),
+  ] = None
+
+  location: Annotated[
+      str | None,
+      (
+          'Vertex AI service location. Or set from environment variable '
+          'VERTEXAI_LOCATION.'
+      ),
+  ] = None
+
+  credentials: Annotated[
+      credentials_lib.Credentials | None,
+      (
+          'Credentials to use. If None, the default credentials to the '
+          'environment will be used.'
+      ),
+  ] = None
+
+  multimodal: Annotated[bool, 'Whether this model has multimodal support.'] = (
+      False
+  )
+
+  def _on_bound(self):
+    super()._on_bound()
+    self.__dict__.pop('_api_initialized', None)
+
+  @functools.cached_property
+  def _api_initialized(self):
+    project = self.project or os.environ.get('VERTEXAI_PROJECT', None)
+    if not project:
+      raise ValueError(
+          'Please specify `project` during `__init__` or set environment '
+          'variable `VERTEXAI_PROJECT` with your Vertex AI project ID.'
+      )
+
+    location = self.location or os.environ.get('VERTEXAI_LOCATION', None)
+    if not location:
+      raise ValueError(
+          'Please specify `location` during `__init__` or set environment '
+          'variable `VERTEXAI_LOCATION` with your Vertex AI service location.'
+      )
+
+    credentials = self.credentials
+    # Placeholder for Google-internal credentials.
+    from google.cloud.aiplatform import vertexai  # pylint: disable=g-import-not-at-top
+    vertexai.init(project=project, location=location, credentials=credentials)
+    return True
+
+  @property
+  def model_id(self) -> str:
+    """Returns a string to identify the model."""
+    return f'VertexAI({self.model})'
+
+  @property
+  def resource_id(self) -> str:
+    """Returns a string to identify the resource for rate control."""
+    return self.model_id
+
+  @property
+  def max_concurrency(self) -> int:
+    """Returns the maximum number of concurrent requests."""
+    return self.rate_to_max_concurrency(
+        requests_per_min=SUPPORTED_MODELS_AND_SETTINGS[self.model].rpm,
+        tokens_per_min=0,
+    )
+
+  def _generation_config(
+      self, options: lf.LMSamplingOptions
+  ) -> Any:  # generative_models.GenerationConfig
+    """Creates generation config from langfun sampling options."""
+    from google.cloud.aiplatform.vertexai.preview import generative_models  # pylint: disable=g-import-not-at-top
+    return generative_models.GenerationConfig(
+        temperature=options.temperature,
+        top_p=options.top_p,
+        top_k=options.top_k,
+        max_output_tokens=options.max_tokens,
+        stop_sequences=options.stop,
+    )
+
+  def _content_from_message(
+      self, prompt: lf.Message
+  ) -> list[str | Any]:
+    """Gets generation input from langfun message."""
+    from google.cloud.aiplatform.vertexai.preview import generative_models  # pylint: disable=g-import-not-at-top
+    chunks = []
+    for lf_chunk in prompt.chunk():
+      if isinstance(lf_chunk, str):
+        chunk = lf_chunk
+      elif self.multimodal and isinstance(lf_chunk, lf_modalities.Image):
+        chunk = generative_models.Image.from_bytes(lf_chunk.to_bytes())
+      else:
+        raise ValueError(f'Unsupported modality: {lf_chunk!r}')
+      chunks.append(chunk)
+    return chunks
+
+  def _generation_response_to_message(
+      self,
+      response: Any,  # generative_models.GenerationResponse
+  ) -> lf.Message:
+    """Parses generative response into message."""
+    return lf.AIMessage(response.text)
+
+  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
+    assert self._api_initialized, 'Vertex AI API is not initialized.'
+    return lf.concurrent_execute(
+        self._sample_single,
+        prompts,
+        executor=self.resource_id,
+        max_workers=self.max_concurrency,
+        # NOTE(daiyip): Vertex has its own policy on handling
+        # with rate limit, so we do not retry on errors.
+        retry_on_errors=None,
+    )
+
+  def _sample_single(self, prompt: lf.Message) -> lf.LMSamplingResult:
+    if self.sampling_options.n > 1:
+      raise ValueError(
+          f'`n` greater than 1 is not supported: {self.sampling_options.n}.'
+      )
+    api = SUPPORTED_MODELS_AND_SETTINGS[self.model].api
+    match api:
+      case 'gemini':
+        return self._sample_generative_model(prompt)
+      case 'palm':
+        return self._sample_text_generation_model(prompt)
+      case _:
+        raise ValueError(f'Unsupported API: {api}')
+
+  def _sample_generative_model(self, prompt: lf.Message) -> lf.LMSamplingResult:
+    """Samples a generative model."""
+    model = _VERTEXAI_MODEL_HUB.get_generative_model(self.model)
+    input_content = self._content_from_message(prompt)
+    response = model.generate_content(
+        input_content,
+        generation_config=self._generation_config(self.sampling_options),
+    )
+    usage_metadata = response.usage_metadata
+    usage = lf.LMSamplingUsage(
+        prompt_tokens=usage_metadata.prompt_token_count,
+        completion_tokens=usage_metadata.candidates_token_count,
+        total_tokens=usage_metadata.total_token_count,
+    )
+    return lf.LMSamplingResult(
+        [
+            # Scoring is not supported.
+            lf.LMSample(
+                self._generation_response_to_message(response), score=0.0
+            ),
+        ],
+        usage=usage,
+    )
+
+  def _sample_text_generation_model(
+      self, prompt: lf.Message
+  ) -> lf.LMSamplingResult:
+    """Samples a text generation model."""
+    model = _VERTEXAI_MODEL_HUB.get_text_generation_model(self.model)
+    predict_options = dict(
+        temperature=self.sampling_options.temperature,
+        top_k=self.sampling_options.top_k,
+        top_p=self.sampling_options.top_p,
+        max_output_tokens=self.sampling_options.max_tokens,
+        stop_sequences=self.sampling_options.stop,
+    )
+    response = model.predict(prompt.text, **predict_options)
+    return lf.LMSamplingResult([
+        # Scoring is not supported.
+        lf.LMSample(lf.AIMessage(response.text), score=0.0)
+    ])
+
+
+class _ModelHub:
+  """Vertex AI model hub."""
+
+  def __init__(self):
+    self._generative_model_cache = {}
+    self._text_generation_model_cache = {}
+
+  def get_generative_model(
+      self, model_id: str
+  ) -> Any:  # generative_models.GenerativeModel:
+    """Gets a generative model by model id."""
+    model = self._generative_model_cache.get(model_id, None)
+    if model is None:
+      from google.cloud.aiplatform.vertexai.preview import generative_models  # pylint: disable=g-import-not-at-top
+      model = generative_models.GenerativeModel(model_id)
+      self._generative_model_cache[model_id] = model
+    return model
+
+  def get_text_generation_model(
+      self, model_id: str
+  ) -> Any:  # language_models.TextGenerationModel
+    """Gets a text generation model by model id."""
+    model = self._text_generation_model_cache.get(model_id, None)
+    if model is None:
+      from google.cloud.aiplatform.vertexai import language_models  # pylint: disable=g-import-not-at-top
+      model = language_models.TextGenerationModel.from_pretrained(model_id)
+      self._text_generation_model_cache[model_id] = model
+    return model
+
+
+_VERTEXAI_MODEL_HUB = _ModelHub()
+
+
+class VertexAIGeminiPro1_5(VertexAI):  # pylint: disable=invalid-name
+  """Vertex AI Gemini 1.5 Pro model."""
+
+  model = 'gemini-1.5-pro-preview-0409'
+  multimodal = True
+
+
+class VertexAIGeminiPro1(VertexAI):  # pylint: disable=invalid-name
+  """Vertex AI Gemini 1.0 Pro model."""
+
+  model = 'gemini-1.0-pro'
+
+
+class VertexAIGeminiPro1Vision(VertexAI):  # pylint: disable=invalid-name
+  """Vertex AI Gemini 1.0 Pro model."""
+
+  model = 'gemini-1.0-pro-vision'
+  multimodal = True
+
+
+class VertexAIPalm2(VertexAI):  # pylint: disable=invalid-name
+  """Vertex AI PaLM2 text generation model."""
+
+  model = 'text-bison'
+
+
+class VertexAIPalm2_32K(VertexAI):  # pylint: disable=invalid-name
+  """Vertex AI PaLM2 text generation model (32K context length)."""
+
+  model = 'text-bison-32k'

langfun/core/llms/vertexai_test.py

@@ -0,0 +1,233 @@
+# 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 Gemini models."""
+
+import os
+import unittest
+from unittest import mock
+
+from google.cloud.aiplatform.vertexai.preview import generative_models
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+from langfun.core.llms import vertexai
+import pyglove as pg
+
+
+example_image = (
+    b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x04'
+    b'\x03\x00\x00\x00\x12Y \xcb\x00\x00\x00\x18PLTE\x00\x00'
+    b'\x00fff_chaag_cg_ch^ci_ciC\xedb\x94\x00\x00\x00\x08tRNS'
+    b'\x00\n\x9f*\xd4\xff_\xf4\xe4\x8b\xf3a\x00\x00\x00>IDATx'
+    b'\x01c \x05\x08)"\xd8\xcc\xae!\x06pNz\x88k\x19\\Q\xa8"\x10'
+    b'\xc1\x14\x95\x01%\xc1\n\xa143Ta\xa8"D-\x84\x03QM\x98\xc3'
+    b'\x1a\x1a\x1a@5\x0e\x04\xa0q\x88\x05\x00\x07\xf8\x18\xf9'
+    b'\xdao\xd0|\x00\x00\x00\x00IEND\xaeB`\x82'
+)
+
+
+def mock_generate_content(content, generation_config, **kwargs):
+  del kwargs
+  c = pg.Dict(generation_config.to_dict())
+  print('zzz', c)
+  return generative_models.GenerationResponse.from_dict({
+      'candidates': [
+          {
+              'index': 0,
+              'content': {
+                  'role': 'model',
+                  'parts': [
+                      {
+                          'text': (
+                              f'This is a response to {content[0]} with '
+                              f'temperature={c.temperature}, '
+                              f'top_p={c.top_p}, '
+                              f'top_k={c.top_k}, '
+                              f'max_tokens={c.max_output_tokens}, '
+                              f'stop={"".join(c.stop_sequences)}.'
+                          )
+                      },
+                  ],
+              },
+          },
+      ]
+  })
+
+
+class VertexAITest(unittest.TestCase):
+  """Tests for Vertex model."""
+
+  def test_content_from_message_text_only(self):
+    text = 'This is a beautiful day'
+    model = vertexai.VertexAIGeminiPro1()
+    chunks = model._content_from_message(lf.UserMessage(text))
+    self.assertEqual(chunks, [text])
+
+  def test_content_from_message_mm(self):
+    message = lf.UserMessage(
+        'This is an {{image}}, what is it?',
+        image=lf_modalities.Image.from_bytes(example_image),
+    )
+
+    # Non-multimodal model.
+    with self.assertRaisesRegex(ValueError, 'Unsupported modality'):
+      vertexai.VertexAIGeminiPro1()._content_from_message(message)
+
+    model = vertexai.VertexAIGeminiPro1Vision()
+    chunks = model._content_from_message(message)
+    self.maxDiff = None
+    self.assertEqual([chunks[0], chunks[2]], ['This is an', ', what is it?'])
+    self.assertIsInstance(chunks[1], generative_models.Image)
+
+  def test_generation_response_to_message_text_only(self):
+    response = generative_models.GenerationResponse.from_dict({
+        'candidates': [
+            {
+                'index': 0,
+                'content': {
+                    'role': 'model',
+                    'parts': [
+                        {
+                            'text': 'hello world',
+                        },
+                    ],
+                },
+            },
+        ],
+    })
+    model = vertexai.VertexAIGeminiPro1()
+    message = model._generation_response_to_message(response)
+    self.assertEqual(message, lf.AIMessage('hello world'))
+
+  def test_model_hub(self):
+    with mock.patch(
+        'google.cloud.aiplatform.vertexai.preview.generative_models.'
+        'GenerativeModel.__init__'
+    ) as mock_model_init:
+      mock_model_init.side_effect = lambda *args, **kwargs: None
+      model = vertexai._VERTEXAI_MODEL_HUB.get_generative_model(
+          'gemini-1.0-pro'
+      )
+      self.assertIsNotNone(model)
+      self.assertIs(
+          vertexai._VERTEXAI_MODEL_HUB.get_generative_model('gemini-1.0-pro'),
+          model,
+      )
+
+    with mock.patch(
+        'google.cloud.aiplatform.vertexai.language_models.'
+        'TextGenerationModel.from_pretrained'
+    ) as mock_model_init:
+
+      class TextGenerationModel:
+        pass
+
+      mock_model_init.side_effect = lambda *args, **kw: TextGenerationModel()
+      model = vertexai._VERTEXAI_MODEL_HUB.get_text_generation_model(
+          'text-bison'
+      )
+      self.assertIsNotNone(model)
+      self.assertIs(
+          vertexai._VERTEXAI_MODEL_HUB.get_text_generation_model('text-bison'),
+          model,
+      )
+
+  def test_project_and_location_check(self):
+    with self.assertRaisesRegex(ValueError, 'Please specify `project`'):
+      _ = vertexai.VertexAIGeminiPro1()._api_initialized
+
+    with self.assertRaisesRegex(ValueError, 'Please specify `location`'):
+      _ = vertexai.VertexAIGeminiPro1(project='abc')._api_initialized
+
+    self.assertTrue(
+        vertexai.VertexAIGeminiPro1(
+            project='abc', location='us-central1'
+        )._api_initialized
+    )
+
+    os.environ['VERTEXAI_PROJECT'] = 'abc'
+    os.environ['VERTEXAI_LOCATION'] = 'us-central1'
+    self.assertTrue(vertexai.VertexAIGeminiPro1()._api_initialized)
+    del os.environ['VERTEXAI_PROJECT']
+    del os.environ['VERTEXAI_LOCATION']
+
+  def test_call_generative_model(self):
+    with mock.patch(
+        'google.cloud.aiplatform.vertexai.preview.generative_models.'
+        'GenerativeModel.__init__'
+    ) as mock_model_init:
+      mock_model_init.side_effect = lambda *args, **kwargs: None
+
+      with mock.patch(
+          'google.cloud.aiplatform.vertexai.preview.generative_models.'
+          'GenerativeModel.generate_content'
+      ) as mock_generate:
+        mock_generate.side_effect = mock_generate_content
+
+        lm = vertexai.VertexAIGeminiPro1(project='abc', location='us-central1')
+        self.assertEqual(
+            lm(
+                'hello',
+                temperature=2.0,
+                top_p=1.0,
+                top_k=20,
+                max_tokens=1024,
+                stop='\n',
+            ).text,
+            (
+                'This is a response to hello with temperature=2.0, '
+                'top_p=1.0, top_k=20.0, max_tokens=1024, stop=\n.'
+            ),
+        )
+
+  def test_call_text_generation_model(self):
+    with mock.patch(
+        'google.cloud.aiplatform.vertexai.language_models.'
+        'TextGenerationModel.from_pretrained'
+    ) as mock_model_init:
+
+      class TextGenerationModel:
+
+        def predict(self, prompt, **kwargs):
+          c = pg.Dict(kwargs)
+          return pg.Dict(
+              text=(
+                  f'This is a response to {prompt} with '
+                  f'temperature={c.temperature}, '
+                  f'top_p={c.top_p}, '
+                  f'top_k={c.top_k}, '
+                  f'max_tokens={c.max_output_tokens}, '
+                  f'stop={"".join(c.stop_sequences)}.'
+              )
+          )
+
+      mock_model_init.side_effect = lambda *args, **kw: TextGenerationModel()
+      lm = vertexai.VertexAIPalm2(project='abc', location='us-central1')
+      self.assertEqual(
+          lm(
+              'hello',
+              temperature=2.0,
+              top_p=1.0,
+              top_k=20,
+              max_tokens=1024,
+              stop='\n',
+          ).text,
+          (
+              'This is a response to hello with temperature=2.0, '
+              'top_p=1.0, top_k=20, max_tokens=1024, stop=\n.'
+          ),
+      )
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/modalities/image.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 """Image modality."""
 
-import base64
 import imghdr
 from typing import cast
 from langfun.core.modalities import mime
@@ -36,5 +35,4 @@ class Image(mime.MimeType):
   def _repr_html_(self) -> str:
     if self.uri and self.uri.lower().startswith(('http:', 'https:', 'ftp:')):
       return f'<img src="{self.uri}">'
-    image_raw = base64.b64encode(self.to_bytes()).decode()
-    return f'<img src="data:image/{self.image_format};base64,{image_raw}">'
+    return f'<img src="{self.content_uri}">'

langfun/core/modalities/mime.py

@@ -14,6 +14,7 @@
 """MIME type data."""
 
 import abc
+import base64
 from typing import Annotated, Union
 import langfun.core as lf
 import pyglove as pg
@@ -54,6 +55,11 @@ class MimeType(lf.Modality):
     self.rebind(content=content, skip_notification=True)
     return self.content
 
+  @property
+  def content_uri(self) -> str:
+    base64_content = base64.b64encode(self.to_bytes()).decode()
+    return f'data:{self.mime_type};base64,{base64_content}'
+
   @classmethod
   def from_uri(cls, uri: str, **kwargs) -> 'MimeType':
     return cls(uri=uri, content=None, **kwargs)

langfun/core/modalities/video.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 """Video modality."""
 
-import base64
 from typing import cast
 from langfun.core.modalities import mime
 
@@ -40,8 +39,7 @@ class Video(mime.MimeType):
   def _repr_html_(self) -> str:
     if self.uri and self.uri.lower().startswith(('http:', 'https:', 'ftp:')):
       return f'<video controls> <source src="{self.uri}"> </video>'
-    video_raw = base64.b64encode(self.to_bytes()).decode()
     return (
         '<video controls> <source'
-        f' src="data:video/{self.video_format};base64,{video_raw}"> </video>'
+        f' src="data:video/{self.content_uri}"> </video>'
     )

langfun/core/structured/__init__.py

@@ -64,6 +64,8 @@ from langfun.core.structured.prompting import QueryStructure
 from langfun.core.structured.prompting import QueryStructureJson
 from langfun.core.structured.prompting import QueryStructurePython
 from langfun.core.structured.prompting import query
+from langfun.core.structured.prompting import query_prompt
+from langfun.core.structured.prompting import query_output
 
 from langfun.core.structured.description import DescribeStructure
 from langfun.core.structured.description import describe

langfun/core/structured/prompting.py

@@ -16,6 +16,7 @@
 from typing import Any, Callable, Type, Union
 
 import langfun.core as lf
+from langfun.core.llms import fake
 from langfun.core.structured import mapping
 from langfun.core.structured import schema as schema_lib
 import pyglove as pg
@@ -214,13 +215,8 @@ def query(
   # prompt rendering.
   prompt_kwargs.pop('template_str', None)
 
-  if isinstance(prompt, str):
-    prompt = lf.Template(prompt, **prompt_kwargs)
-  elif isinstance(prompt, lf.Template):
-    prompt = prompt.rebind(**prompt_kwargs, raise_on_no_change=False)
-
-  if isinstance(prompt, lf.Template):
-    prompt = prompt.render(lm=lm)
+  if isinstance(prompt, (str, lf.Message, lf.Template)):
+    prompt = lf.Template.from_value(prompt, **prompt_kwargs).render(lm=lm)
   else:
     prompt = schema_lib.mark_missing(prompt)
 
@@ -240,3 +236,31 @@ def query(
       skip_lm=skip_lm,
   )
   return output if returns_message else output.result
+
+
+def query_prompt(
+    prompt: Union[str, pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    **kwargs,
+) -> lf.Message:
+  """Returns the final prompt sent to LLM for `lf.query`."""
+  kwargs.pop('returns_message', None)
+  kwargs.pop('skip_lm', None)
+  return query(prompt, schema, skip_lm=True, returns_message=True, **kwargs)
+
+
+def query_output(
+    response: Union[str, lf.Message],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ],
+    **kwargs,
+) -> Any:
+  """Returns the final output of `lf.query` from a provided LLM response."""
+  kwargs.pop('prompt', None)
+  kwargs.pop('lm', None)
+  return query(
+      'Unused prompt', schema, lm=fake.StaticResponse(response), **kwargs
+  )

langfun/core/structured/prompting_test.py

@@ -285,6 +285,49 @@ class QueryTest(unittest.TestCase):
     with self.assertRaisesRegex(ValueError, 'Unknown protocol'):
       prompting.query('what is 1 + 1', int, protocol='text')
 
+  def test_query_prompt(self):
+    self.assertEqual(
+        prompting.query_prompt('what is this?', int),
+        inspect.cleandoc("""
+            Please respond to the last INPUT_OBJECT with OUTPUT_OBJECT according to OUTPUT_TYPE.
+
+            INPUT_OBJECT:
+              1 + 1 =
+
+            OUTPUT_TYPE:
+              Answer
+
+              ```python
+              class Answer:
+                final_answer: int
+              ```
+
+            OUTPUT_OBJECT:
+              ```python
+              Answer(
+                final_answer=2
+              )
+              ```
+
+            INPUT_OBJECT:
+              what is this?
+
+            OUTPUT_TYPE:
+              int
+
+            OUTPUT_OBJECT:
+            """),
+    )
+
+  def test_query_output(self):
+    self.assertEqual(
+        prompting.query_output(
+            lf.AIMessage('1'),
+            int,
+        ),
+        1,
+    )
+
 
 class QueryStructurePythonTest(unittest.TestCase):
 

langfun/core/template.py

@@ -17,7 +17,7 @@ import contextlib
 import dataclasses
 import functools
 import inspect
-from typing import Annotated, Any, Callable, Iterator, Set, Tuple, Type
+from typing import Annotated, Any, Callable, Iterator, Set, Tuple, Type, Union
 
 import jinja2
 from jinja2 import meta as jinja2_meta
@@ -495,6 +495,27 @@ class Template(
     t.sym_setparent(self)
     return t
 
+  @classmethod
+  def from_value(
+      cls,
+      value: Union[str, message_lib.Message, 'Template'],
+      **kwargs
+  ) -> 'Template':
+    """Create a template object from a string or template."""
+    if isinstance(value, cls):
+      return value.clone(override=kwargs) if kwargs else value  # pylint: disable=no-value-for-parameter
+    if isinstance(value, str):
+      return cls(template_str=value, **kwargs)
+    if isinstance(value, message_lib.Message):
+      kwargs.update(value.metadata)
+      return cls(template_str=value.text, **kwargs)
+    if isinstance(value, Template):
+      lfun = cls(template_str=value.template_str, **kwargs)
+      # So lfun could acccess all attributes from value.
+      lfun.sym_setparent(value)
+      return lfun
+    return cls(template_str='{{input}}', input=value, **kwargs)
+
 
 # Register converter from str to LangFunc, therefore we can always
 # pass strs to attributes that accept LangFunc.

{langfun-0.0.2.dev20240507.dist-info → langfun-0.0.2.dev20240513.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240507
+Version: 0.0.2.dev20240513
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,6 +21,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: google-cloud-aiplatform >=1.5.0
 Requires-Dist: google-generativeai >=0.3.2
 Requires-Dist: jinja2 >=3.1.2
 Requires-Dist: openai ==0.27.2

{langfun-0.0.2.dev20240507.dist-info → langfun-0.0.2.dev20240513.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langfun/__init__.py,sha256=zh-EYTCLxkUAIc2zMo3Lye46_CrMrhwO_GwBHZspUvE,1919
+langfun/__init__.py,sha256=YAbi2FfTfKT41KJAx1tSNoiole_YRJmcEk3oOoqFqOs,2128
 langfun/core/__init__.py,sha256=6QEuXOZ9BXxm6TjpaMXuLwUBTYO3pkFDqn9QVBXyyPQ,4248
 langfun/core/component.py,sha256=oxesbC0BoE_TbtxwW5x-BAZWxZyyJbuPiX5S38RqCv0,9909
 langfun/core/component_test.py,sha256=uR-_Sz_42Jxc5qzLIB-f5_pXmNwnC01Xlbv5NOQSeSU,8021
@@ -6,8 +6,8 @@ langfun/core/concurrent.py,sha256=TRc49pJ3HQro2kb5FtcWkHjhBm8UcgE8RJybU5cU3-0,24
 langfun/core/concurrent_test.py,sha256=mwFMZhDUdppnDr7vDSTwcbMHwrdsIoKJwRYNtl4ZWL4,15185
 langfun/core/console.py,sha256=bk5rNPNm9rMGW5YT2HixxU04p2umnoabn5SDz6Dqe88,2317
 langfun/core/console_test.py,sha256=5SYJdxpJGLgdSSQqqMPoA1X6jpsLD8rgcyk-EgI65oE,1077
-langfun/core/langfunc.py,sha256=bRujJfH4iTwKFtFxQf745uJkfltuFnPfOGLuP8ydcr4,11646
-langfun/core/langfunc_test.py,sha256=sQaKuZpGGmG80GRifhbxkj7nfzQLJKj4Vuw5y1s1K3U,8378
+langfun/core/langfunc.py,sha256=RvIcRjIq0jWYRu1xim-FYe4HSrt97r3GMBO_PuagUmw,11060
+langfun/core/langfunc_test.py,sha256=_mfARnakX3oji5HDigFSLMd6yQ2wma-2Mgbztwqn73g,8501
 langfun/core/language_model.py,sha256=6wtY8RGbOymfo1PYzcYCfOlWuKQcSVFs5R1sFB4-QMQ,20202
 langfun/core/language_model_test.py,sha256=T-itu7Li2smv2dkru0C0neCs2W4VJXlNTYahXU6jF54,19548
 langfun/core/memory.py,sha256=f-asN1F7Vehgdn_fK84v73GrEUOxRtaW934keutTKjk,2416
@@ -21,7 +21,7 @@ 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
 langfun/core/subscription_test.py,sha256=Y4ZdbZEwm83YNZBxHff0QR4QUa4rdaNXA3_jfIcArBo,8717
-langfun/core/template.py,sha256=FZByYq6mhVDjT4HJ3yY-_TUZ13BiURzTJSKLw6QyLY4,21462
+langfun/core/template.py,sha256=UhNNGUDJ4StUhPBKzHmjym36khxHOGWGr9MDxBwgxQA,22284
 langfun/core/template_test.py,sha256=Mbv0dFjboGCVvbDkHD-HacZnlCi8Ku2Hpf2UjdwGSNo,15464
 langfun/core/text_formatting.py,sha256=ytjj7opnRJ6w-pkglL2CZUyfYDXLpNf65E42LBb31gc,5158
 langfun/core/text_formatting_test.py,sha256=nyKC6tn2L4hPJiqQHgxcbQsJJi4A4Nbj8FiO8iT6B80,1514
@@ -40,7 +40,7 @@ langfun/core/coding/python/parsing_test.py,sha256=9vAWF484kWIm6JZq8NFiMgKUDhXV-d
 langfun/core/coding/python/permissions.py,sha256=1QWGHvzL8MM0Ok_auQ9tURqZHtdOfJaDpBzZ29GUE-c,2544
 langfun/core/coding/python/permissions_test.py,sha256=w5EDb8QxpxgJyZkojyzVWQvDfg366zn99-g__6TbPQ0,2699
 langfun/core/eval/__init__.py,sha256=Evt-E4FEhZF2tXL6-byh_AyA7Cc_ZoGmvnN7vkAZedk,1898
-langfun/core/eval/base.py,sha256=ZUx-rBjdWyJ5augNIUgRF77-FE-YdFum2uqe0h7-baM,74132
+langfun/core/eval/base.py,sha256=zcMPBKmcll5O08waEEnvmkEoXgcINhOat9rRJk8X8b4,74268
 langfun/core/eval/base_test.py,sha256=cHOTIWVW4Dp8gKKIKcZrAcJ-w84j2GIozTzJoiAX7p4,26743
 langfun/core/eval/matching.py,sha256=Y4vFoNTQEOwko6IA8l9OZ52-vt52e3VGmcTtvLA67wM,9782
 langfun/core/eval/matching_test.py,sha256=f7iVyXH5KGJBWt4Wp14Bt9J3X59A6Ayfog9MbuFvPew,5532
@@ -48,19 +48,21 @@ langfun/core/eval/patching.py,sha256=R0s2eAd1m97exQt06dmUL0V_MBG0W2Hxg7fhNB7cXW0
 langfun/core/eval/patching_test.py,sha256=8kCd54Egjju22FMgtJuxEsrXkW8ifs-UUBHtrCG1L6w,4775
 langfun/core/eval/scoring.py,sha256=1J7IATo-8FXUR0SBqk9icztHiM0lWkBFcWUo-vUURgQ,6376
 langfun/core/eval/scoring_test.py,sha256=O8olHbrUEg60gMxwOkWzKBJZpZoUlmVnBANX5Se2SXM,4546
-langfun/core/llms/__init__.py,sha256=1bPg1QI8duOZCYINm-jWi094x0JtLmsk4KX60qIC_gs,3245
+langfun/core/llms/__init__.py,sha256=C-NrcgFqf3_EP_dN8oADdckQ-rfPKZhsjeSf86kJpLk,3642
 langfun/core/llms/anthropic.py,sha256=7W9YdPN3SlAFhAIQlihMkrpo7tTY_4NvD0KIlCrqcsk,8505
 langfun/core/llms/anthropic_test.py,sha256=TMM30myyEhwF99Le4RvJEXOn8RYl0q1FRkt9Q9nl1jk,5540
-langfun/core/llms/fake.py,sha256=b-Xk5IPTbUt-elsyzd_i3n1tqzc_kgETXrEvgJruSMk,2824
+langfun/core/llms/fake.py,sha256=_smsN_CsYbeWrtjpegEPwdAPV9mwaIuH_4oZGeXQwQI,2896
 langfun/core/llms/fake_test.py,sha256=ipKfdOcuqVcJ8lDXVpnBVb9HHG0hAVkFkMoHpWjC2cI,7212
-langfun/core/llms/google_genai.py,sha256=n8zyJwh9UCTgb6-8LyvmjVNFGZQ4-zfzZ0ulkhHAnR8,8624
+langfun/core/llms/google_genai.py,sha256=nDI_Adur_K458l6EWoiiAhzjfnjRSqfTiikdu7iLPyU,8808
 langfun/core/llms/google_genai_test.py,sha256=_UcGTfl16-aDUlEWFC2W2F8y9jPUs53RBYA6MOCpGXw,7525
 langfun/core/llms/groq.py,sha256=NaGItVL_pkOpqPpI4bPGU27xLFRoaeizZ49v2s-4ERs,7844
 langfun/core/llms/groq_test.py,sha256=M6GtlrsOvDun_j-sR8cPh4W_moHWZNSTiThu3kuwbbc,5281
 langfun/core/llms/llama_cpp.py,sha256=Y_KkMUf3Xfac49koMUtUslKl3h-HWp3-ntq7Jaa3bdo,2385
 langfun/core/llms/llama_cpp_test.py,sha256=ZxC6defGd_HX9SFRU9U4cJiQnBKundbOrchbXuC1Z2M,1683
-langfun/core/llms/openai.py,sha256=rPwO4qPGEwbB4O7TaQD0spg_PXIfF2ioRI_ilE3Pg6Y,13257
+langfun/core/llms/openai.py,sha256=u2lqYcKFjFxLfWYD0KLT3YThqcoo66rWs3n0bcuSYBs,13286
 langfun/core/llms/openai_test.py,sha256=asSA1sVy_7hnXioD_2HTxtSDpVTKBUO_EjZuyHpwbn0,14854
+langfun/core/llms/vertexai.py,sha256=O2Lp-F4KJzvQSCjPV--sa6nMS9-GsLj2eiqA-1qGhWQ,9661
+langfun/core/llms/vertexai_test.py,sha256=LBk4luL_N13ZejZebBzQ3tkfjxFhk7uBS4JjEpojJAo,7836
 langfun/core/llms/cache/__init__.py,sha256=QAo3InUMDM_YpteNnVCSejI4zOsnjSMWKJKzkb3VY64,993
 langfun/core/llms/cache/base.py,sha256=cFfYvOIUae842pncqCAsRvqXCk2AnAsRYVx0mcIoAeY,3338
 langfun/core/llms/cache/in_memory.py,sha256=YfFyJEhLs73cUiB0ZfhMxYpdE8Iuxxw-dvMFwGHTSHw,4742
@@ -69,13 +71,13 @@ langfun/core/memories/__init__.py,sha256=HpghfZ-w1NQqzJXBx8Lz0daRhB2rcy2r9Xm491S
 langfun/core/memories/conversation_history.py,sha256=c9amD8hCxGFiZuVAzkP0dOMWSp8L90uvwkOejjuBqO0,1835
 langfun/core/memories/conversation_history_test.py,sha256=AaW8aNoFjxNusanwJDV0r3384Mg0eAweGmPx5DIkM0Y,2052
 langfun/core/modalities/__init__.py,sha256=ldCbs1HHAHAJECNu19vppA0sWEidI40xBs4W1F_YOlo,1073
-langfun/core/modalities/image.py,sha256=zNpLHwJi6PJMeeAcVQG6vn0oYIbilTuJq6xu-TvrArM,1358
+langfun/core/modalities/image.py,sha256=MUqRCQYyP7Gcf3dmzjU9J9ZEpfI08gAli9ZDmk0bJEk,1254
 langfun/core/modalities/image_test.py,sha256=YxDRvC49Bjwyyndd_P7y6XjyS7dOft0Zewwxk-7q4kE,2301
-langfun/core/modalities/mime.py,sha256=wVfaYflhGz1W4v3m972rAplW3OGOFtjFpHDYIaUD5D0,2238
+langfun/core/modalities/mime.py,sha256=RatBOPqYEneYMe-lfgRxJp5T3yvgV6vBMNY8lK2WU8k,2421
 langfun/core/modalities/mime_test.py,sha256=cVHxRvJ1QXC1SVhBmWkJdWGpL9Xl0UNfTQq6j0OGGL4,1881
-langfun/core/modalities/video.py,sha256=25M4XsNG5XEWRy57LYT_a6_aMURMPAgC41B3weEXFsY,1747
+langfun/core/modalities/video.py,sha256=bzJLeBDF6FIVHyrAvRqYcQq2pCLBqN-UIgX_f3lM3E0,1654
 langfun/core/modalities/video_test.py,sha256=jYuI2m8S8zDCAVBPEUbbpP205dXAht90A2_PHWo4-r8,2039
-langfun/core/structured/__init__.py,sha256=zO6mdApZgWy6d2i3s_FWrjHS_-7qWnase0VRq0KhKn0,3589
+langfun/core/structured/__init__.py,sha256=Qg1ocwsb60od8fJky3F3JAOhwjwT9WA7IX3C2j2s3zA,3707
 langfun/core/structured/completion.py,sha256=skBxt6V_fv2TBUKnzFgnPMbVY8HSYn8sY04MLok2yvs,7299
 langfun/core/structured/completion_test.py,sha256=MYxEzeScC3gFVujvrMMboBF5nh-QiVLwGgqAV3oaFUQ,19273
 langfun/core/structured/description.py,sha256=SXW4MJvshFjbR-0gw6rE21o6WXq12UlRXawvDBXMZFA,5211
@@ -86,8 +88,8 @@ langfun/core/structured/mapping.py,sha256=V2EI53KwhXxqcoH2ouhuei8aYWny0ml_FwMTiS
 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=mzQwZBQi2RU3-W8RNdlr_tr_9G6UA2Z9QuowyzcC9ww,8099
-langfun/core/structured/prompting_test.py,sha256=vslaCAUikfwOvqsKzqs_oyEacrefFsr2SWSqu6OHi3w,20813
+langfun/core/structured/prompting.py,sha256=cswl9c93edsYnXsZQmMzPpmqOuKnBzbgebTYBbSxwzo,8815
+langfun/core/structured/prompting_test.py,sha256=rddf5qHN8Gm_JaNMmytwiVEBm-eZVJFLQO4GljUgR44,21700
 langfun/core/structured/schema.py,sha256=Zy9y6Vq9DrFwcuP5o5VL_PvMCmzavF-nuDqyviBnaxk,25818
 langfun/core/structured/schema_generation.py,sha256=U3nRQsqmMZg_qIVDh2fiY3K4JLfsAL1LcKzIFP1iXFg,5316
 langfun/core/structured/schema_generation_test.py,sha256=RM9s71kMNg2jTePwInkiW9fK1ACN37eyPeF8OII-0zw,2950
@@ -103,8 +105,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=DYVrkk7uNKCqJGEHH31HssU2BPuMItU1vJLzfcXIlYg,2156
-langfun-0.0.2.dev20240507.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.0.2.dev20240507.dist-info/METADATA,sha256=kz0C5CzRBOml2nNCsUkvDY36x_49qo3HvwS-ifZY_sU,3405
-langfun-0.0.2.dev20240507.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-langfun-0.0.2.dev20240507.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.0.2.dev20240507.dist-info/RECORD,,
+langfun-0.0.2.dev20240513.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.0.2.dev20240513.dist-info/METADATA,sha256=rjYqB2Epk9KuZYcGS-MbSrGnRFo4VDaHwafhCFGnah0,3452
+langfun-0.0.2.dev20240513.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+langfun-0.0.2.dev20240513.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.0.2.dev20240513.dist-info/RECORD,,