langfun 0.0.2.dev20240418__py3-none-any.whl → 0.0.2.dev20240419__py3-none-any.whl

langfun/core/language_model.py

@@ -440,7 +440,7 @@ class LanguageModel(component.Component):
       response.metadata.usage = result.usage
 
       elapse = time.time() - request_start
-      self._debug(prompt, response, call_counter, elapse)
+      self._debug(prompt, response, call_counter, result.usage, elapse)
       return response
 
   def _debug(
@@ -448,35 +448,51 @@ class LanguageModel(component.Component):
       prompt: message_lib.Message,
       response: message_lib.Message,
       call_counter: int,
+      usage: LMSamplingUsage | None,
       elapse: float,
-  ):
+  ) -> None:
     """Outputs debugging information."""
     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)
+      self._debug_model_info(call_counter, usage)
 
     if debug & LMDebugMode.PROMPT:
-      self._debug_prompt(prompt, call_counter)
+      self._debug_prompt(prompt, call_counter, usage)
 
     if debug & LMDebugMode.RESPONSE:
-      self._debug_response(response, call_counter, elapse)
+      self._debug_response(response, call_counter, usage, elapse)
 
-  def _debug_model_info(self, call_counter: int):
+  def _debug_model_info(
+      self, call_counter: int, usage: LMSamplingUsage | None) -> None:
     """Outputs debugging information about the model."""
+    title_suffix = ''
+    if usage and usage.total_tokens != 0:
+      title_suffix = console.colored(
+          f' (total {usage.total_tokens} tokens)', 'red')
+
     console.write(
         self.format(compact=True, use_inferred=True),
-        title=f'[{call_counter}] LM INFO:',
+        title=f'[{call_counter}] LM INFO{title_suffix}:',
         color='magenta',
     )
 
-  def _debug_prompt(self, prompt: message_lib.Message, call_counter: int):
+  def _debug_prompt(
+      self,
+      prompt: message_lib.Message,
+      call_counter: int,
+      usage: LMSamplingUsage | None,
+  ) -> None:
     """Outputs debugging information about the prompt."""
+    title_suffix = ''
+    if usage and usage.prompt_tokens != 0:
+      title_suffix = console.colored(f' ({usage.prompt_tokens} tokens)', 'red')
+
     console.write(
         prompt,
-        title=f'\n[{call_counter}] PROMPT SENT TO LM:',
+        title=f'\n[{call_counter}] PROMPT SENT TO LM{title_suffix}:',
         color='green',
     )
     referred_modalities = prompt.referred_modalities()
@@ -490,12 +506,22 @@ class LanguageModel(component.Component):
       )
 
   def _debug_response(
-      self, response: message_lib.Message, call_counter: int, elapse: float
-  ):
+      self,
+      response: message_lib.Message,
+      call_counter: int,
+      usage: LMSamplingUsage | None,
+      elapse: float
+  ) -> None:
     """Outputs debugging information about the response."""
+    title_suffix = ' ('
+    if usage and usage.completion_tokens != 0:
+      title_suffix += f'{usage.completion_tokens} tokens '
+    title_suffix += f'in {elapse:.2f} seconds)'
+    title_suffix = console.colored(title_suffix, 'red')
+
     console.write(
         str(response) + '\n',
-        title=f'\n[{call_counter}] LM RESPONSE (in {elapse:.2f} seconds):',
+        title=f'\n[{call_counter}] LM RESPONSE{title_suffix}:',
         color='blue',
     )
 
@@ -542,7 +568,7 @@ class LanguageModel(component.Component):
       debug = LMDebugMode.ALL if debug else LMDebugMode.NONE
 
     if debug & LMDebugMode.INFO:
-      self._debug_model_info(call_counter)
+      self._debug_model_info(call_counter, None)
 
     if debug & LMDebugMode.PROMPT:
       console.write(

langfun/core/llms/__init__.py

@@ -57,6 +57,12 @@ from langfun.core.llms.openai import Gpt3Curie
 from langfun.core.llms.openai import Gpt3Babbage
 from langfun.core.llms.openai import Gpt3Ada
 
+from langfun.core.llms.anthropic import Anthropic
+from langfun.core.llms.anthropic import Claude3Opus
+from langfun.core.llms.anthropic import Claude3Sonnet
+from langfun.core.llms.anthropic import Claude3Haiku
+
+
 # LLaMA C++ models.
 from langfun.core.llms.llama_cpp import LlamaCppRemote
 

langfun/core/llms/anthropic.py

@@ -0,0 +1,230 @@
+# 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.
+"""Language models from Anthropic."""
+
+import base64
+import functools
+import os
+from typing import Annotated, Any
+
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+import pyglove as pg
+import requests
+
+
+SUPPORTED_MODELS_AND_SETTINGS = {
+    # See https://docs.anthropic.com/claude/docs/models-overview
+    'claude-3-opus-20240229': pg.Dict(max_tokens=4096, max_concurrency=1),
+    'claude-3-sonnet-20240229': pg.Dict(max_tokens=4096, max_concurrency=4),
+    'claude-3-haiku-20240307': pg.Dict(max_tokens=4096, max_concurrency=16),
+}
+
+
+class AnthropicError(Exception):  # pylint: disable=g-bad-exception-name
+  """Base class for Anthropic errors."""
+
+
+class RateLimitError(AnthropicError):
+  """Error for rate limit reached."""
+
+
+class OverloadedError(AnthropicError):
+  """Anthropic's server is temporarily overloaded."""
+
+
+_ANTHROPIC_MESSAGE_API_ENDPOINT = 'https://api.anthropic.com/v1/messages'
+_ANTHROPIC_API_VERSION = '2023-06-01'
+
+
+@lf.use_init_args(['model'])
+class Anthropic(lf.LanguageModel):
+  """Anthropic LLMs (Claude) through REST APIs.
+
+  See https://docs.anthropic.com/claude/reference/messages_post
+  """
+
+  model: Annotated[  # pytype: disable=invalid-annotation
+      pg.typing.Enum(
+          pg.MISSING_VALUE, list(SUPPORTED_MODELS_AND_SETTINGS.keys())
+      ),
+      'The name of the model to use.',
+  ]
+
+  multimodal: Annotated[bool, 'Whether this model has multimodal support.'] = (
+      True
+  )
+
+  api_key: Annotated[
+      str | None,
+      (
+          'API key. If None, the key will be read from environment variable '
+          "'ANTHROPIC_API_KEY'."
+      ),
+  ] = None
+
+  def _on_bound(self):
+    super()._on_bound()
+    self._api_key = None
+    self.__dict__.pop('_api_initialized', None)
+
+  @functools.cached_property
+  def _api_initialized(self):
+    api_key = self.api_key or os.environ.get('ANTHROPIC_API_KEY', None)
+    if not api_key:
+      raise ValueError(
+          'Please specify `api_key` during `__init__` or set environment '
+          'variable `ANTHROPIC_API_KEY` with your Anthropic API key.'
+      )
+    self._api_key = api_key
+    return True
+
+  @property
+  def model_id(self) -> str:
+    """Returns a string to identify the model."""
+    return self.model
+
+  @property
+  def max_concurrency(self) -> int:
+    return SUPPORTED_MODELS_AND_SETTINGS[self.model].max_concurrency
+
+  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
+    assert self._api_initialized
+    return self._parallel_execute_with_currency_control(
+        self._sample_single, prompts, retry_on_errors=(RateLimitError)
+    )
+
+  def _get_request_args(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+    """Returns a dict as request arguments."""
+    # Authropic requires `max_tokens` to be specified.
+    max_tokens = (
+        options.max_tokens
+        or SUPPORTED_MODELS_AND_SETTINGS[self.model].max_tokens
+    )
+    args = dict(
+        model=self.model,
+        max_tokens=max_tokens,
+        stream=False,
+    )
+    if options.stop:
+      args['stop_sequences'] = options.stop
+    if options.temperature is not None:
+      args['temperature'] = options.temperature
+    if options.top_k is not None:
+      args['top_k'] = options.top_k
+    if options.top_p is not None:
+      args['top_p'] = options.top_p
+    return args
+
+  def _content_from_message(self, prompt: lf.Message) -> list[dict[str, Any]]:
+    """Converts an message to Anthropic's content protocol (list of dicts)."""
+    # Refer: https://docs.anthropic.com/claude/reference/messages-examples
+    if self.multimodal:
+      content = []
+      for chunk in prompt.chunk():
+        if isinstance(chunk, str):
+          item = dict(type='text', text=chunk)
+        elif isinstance(chunk, lf_modalities.Image):
+          # NOTE(daiyip): Anthropic only support image content instead of URL.
+          item = dict(
+              type='image',
+              source=dict(
+                  type='base64',
+                  media_type=chunk.mime_type,
+                  data=base64.b64encode(chunk.to_bytes()).decode(),
+              ),
+          )
+        else:
+          raise ValueError(f'Unsupported modality object: {chunk!r}.')
+        content.append(item)
+      return content
+    else:
+      return [dict(type='text', text=prompt.text)]
+
+  def _message_from_content(self, content: list[dict[str, Any]]) -> lf.Message:
+    """Converts Anthropic's content protocol to message."""
+    # Refer: https://docs.anthropic.com/claude/reference/messages-examples
+    return lf.AIMessage.from_chunks(
+        [x['text'] for x in content if x['type'] == 'text']
+    )
+
+  def _parse_response(self, response: requests.Response) -> lf.LMSamplingResult:
+    """Parses Anthropic's response."""
+    # NOTE(daiyip): Refer https://docs.anthropic.com/claude/reference/errors
+    output = response.json()
+    if response.status_code == 200:
+      message = self._message_from_content(output['content'])
+      input_tokens = output['usage']['input_tokens']
+      output_tokens = output['usage']['output_tokens']
+      return lf.LMSamplingResult(
+          [lf.LMSample(message)],
+          usage=lf.LMSamplingUsage(
+              prompt_tokens=input_tokens,
+              completion_tokens=output_tokens,
+              total_tokens=input_tokens + output_tokens,
+          ),
+      )
+    else:
+      if response.status_code == 429:
+        error_cls = RateLimitError
+      elif response.status_code == 529:
+        error_cls = OverloadedError
+      else:
+        error_cls = AnthropicError
+      error = output['error']
+      raise error_cls(f'{error["type"]}: {error["message"]}')
+
+  def _sample_single(self, prompt: lf.Message) -> lf.LMSamplingResult:
+    request = dict()
+    request.update(self._get_request_args(self.sampling_options))
+    request.update(
+        dict(
+            messages=[
+                dict(role='user', content=self._content_from_message(prompt))
+            ]
+        )
+    )
+    response = requests.post(
+        _ANTHROPIC_MESSAGE_API_ENDPOINT,
+        json=request,
+        headers={
+            'x-api-key': self._api_key,
+            'anthropic-version': _ANTHROPIC_API_VERSION,
+            'content-type': 'application/json',
+        },
+        timeout=self.timeout,
+    )
+    return self._parse_response(response)
+
+
+class Claude3(Anthropic):
+  """Base class for Claude 3 models. 200K input tokens and 4K output tokens."""
+
+
+class Claude3Opus(Claude3):
+  """Anthropic's most powerful model."""
+
+  model = 'claude-3-opus-20240229'
+
+
+class Claude3Sonnet(Claude3):
+  """A balance between between Opus and Haiku."""
+
+  model = 'claude-3-sonnet-20240229'
+
+
+class Claude3Haiku(Claude3):
+  """Anthropic's most compact model."""
+
+  model = 'claude-3-haiku-20240307'

langfun/core/llms/anthropic_test.py

@@ -0,0 +1,167 @@
+# 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.
+"""Tests for Anthropic models."""
+
+import base64
+import os
+from typing import Any
+import unittest
+from unittest import mock
+from langfun.core import modalities as lf_modalities
+from langfun.core.llms import anthropic
+import pyglove as pg
+import requests
+
+
+def mock_requests_post(url: str, json: dict[str, Any], **kwargs):
+  del url, kwargs
+
+  response = requests.Response()
+  response.status_code = 200
+  response._content = pg.to_json_str({
+      'content': [{
+          'type': 'text',
+          'text': (
+              f'hello with temperature={json.get("temperature")}, '
+              f'top_k={json.get("top_k")}, '
+              f'top_p={json.get("top_p")}, '
+              f'max_tokens={json.get("max_tokens")}, '
+              f'stop={json.get("stop_sequences")}.'
+          ),
+      }],
+      'usage': {
+          'input_tokens': 2,
+          'output_tokens': 1,
+      },
+  }).encode()
+  return response
+
+
+image_content = (
+    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_mm_requests_post(url: str, json: dict[str, Any], **kwargs):
+  del url, kwargs
+  v = json['messages'][0]['content'][0]
+  image = lf_modalities.Image.from_bytes(base64.b64decode(v['source']['data']))
+
+  response = requests.Response()
+  response.status_code = 200
+  response._content = pg.to_json_str({
+      'content': [{
+          'type': 'text',
+          'text': f'{v["type"]}: {image.mime_type}',
+      }],
+      'usage': {
+          'input_tokens': 2,
+          'output_tokens': 1,
+      },
+  }).encode()
+  return response
+
+
+def mock_requests_post_error(status_code, error_type, error_message):
+  def _mock_requests(url: str, json: dict[str, Any], **kwargs):
+    del url, json, kwargs
+    response = requests.Response()
+    response.status_code = status_code
+    response._content = pg.to_json_str(
+        {
+            'error': {
+                'type': error_type,
+                'message': error_message,
+            }
+        }
+    ).encode()
+    return response
+
+  return _mock_requests
+
+
+class AuthropicTest(unittest.TestCase):
+
+  def test_basics(self):
+    self.assertEqual(
+        anthropic.Claude3Haiku().model_id, 'claude-3-haiku-20240307'
+    )
+    self.assertEqual(anthropic.Claude3Haiku().max_concurrency, 16)
+
+  def test_api_key(self):
+    lm = anthropic.Claude3Haiku()
+    with self.assertRaisesRegex(ValueError, 'Please specify `api_key`'):
+      lm('hi')
+
+    with mock.patch('requests.post') as mock_request:
+      mock_request.side_effect = mock_requests_post
+
+      lm = anthropic.Claude3Haiku(api_key='fake key')
+      self.assertRegex(lm('hi').text, 'hello.*')
+
+      os.environ['ANTHROPIC_API_KEY'] = 'abc'
+      lm = anthropic.Claude3Haiku()
+      self.assertRegex(lm('hi').text, 'hello.*')
+      del os.environ['ANTHROPIC_API_KEY']
+
+  def test_call(self):
+    with mock.patch('requests.post') as mock_request:
+      mock_request.side_effect = mock_requests_post
+      lm = anthropic.Claude3Haiku(api_key='fake_key')
+      response = lm('hello', temperature=0.0, top_k=0.1, top_p=0.2, stop=['\n'])
+      self.assertEqual(
+          response.text,
+          (
+              'hello with temperature=0.0, top_k=0.1, top_p=0.2, '
+              "max_tokens=4096, stop=['\\n']."
+          ),
+      )
+      self.assertIsNotNone(response.usage)
+      self.assertIsNotNone(response.usage.prompt_tokens, 2)
+      self.assertIsNotNone(response.usage.completion_tokens, 1)
+      self.assertIsNotNone(response.usage.total_tokens, 3)
+
+  def test_mm_call(self):
+    with mock.patch('requests.post') as mock_mm_request:
+      mock_mm_request.side_effect = mock_mm_requests_post
+      lm = anthropic.Claude3Haiku(api_key='fake_key')
+      response = lm(lf_modalities.Image.from_bytes(image_content), lm=lm)
+      self.assertEqual(response.text, 'image: image/png')
+
+  def test_call_errors(self):
+    for status_code, error_type, error_message in [
+        (429, 'rate_limit', 'Rate limit exceeded.'),
+        (529, 'service_unavailable', 'Service unavailable.'),
+        (500, 'bad_request', 'Bad request.'),
+    ]:
+      with mock.patch('requests.post') as mock_mm_request:
+        mock_mm_request.side_effect = mock_requests_post_error(
+            status_code, error_type, error_message
+        )
+        lm = anthropic.Claude3Haiku(api_key='fake_key')
+        with self.assertRaisesRegex(
+            Exception, f'{error_type}: {error_message}'
+        ):
+          lm('hello', lm=lm, max_attempts=1)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/llms/fake_test.py

@@ -39,8 +39,8 @@ class EchoTest(unittest.TestCase):
     with contextlib.redirect_stdout(string_io):
       self.assertEqual(lm('hi'), 'hi')
     debug_info = string_io.getvalue()
-    self.assertIn('[0] LM INFO:', debug_info)
-    self.assertIn('[0] PROMPT SENT TO LM:', debug_info)
+    self.assertIn('[0] LM INFO', debug_info)
+    self.assertIn('[0] PROMPT SENT TO LM', debug_info)
     self.assertIn('[0] LM RESPONSE', debug_info)
 
   def test_score(self):
@@ -84,8 +84,8 @@ class StaticResponseTest(unittest.TestCase):
       self.assertEqual(lm('hi'), canned_response)
 
     debug_info = string_io.getvalue()
-    self.assertIn('[0] LM INFO:', debug_info)
-    self.assertIn('[0] PROMPT SENT TO LM:', debug_info)
+    self.assertIn('[0] LM INFO', debug_info)
+    self.assertIn('[0] PROMPT SENT TO LM', debug_info)
     self.assertIn('[0] LM RESPONSE', debug_info)
 
 

{langfun-0.0.2.dev20240418.dist-info → langfun-0.0.2.dev20240419.dist-info}/METADATA

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

{langfun-0.0.2.dev20240418.dist-info → langfun-0.0.2.dev20240419.dist-info}/RECORD

@@ -8,7 +8,7 @@ langfun/core/console.py,sha256=bk5rNPNm9rMGW5YT2HixxU04p2umnoabn5SDz6Dqe88,2317
 langfun/core/console_test.py,sha256=5SYJdxpJGLgdSSQqqMPoA1X6jpsLD8rgcyk-EgI65oE,1077
 langfun/core/langfunc.py,sha256=WXdTc3QsmGD_n80KD9dFRr5MHpGZ9E_y_Rhtk4t9-3w,11852
 langfun/core/langfunc_test.py,sha256=sQaKuZpGGmG80GRifhbxkj7nfzQLJKj4Vuw5y1s1K3U,8378
-langfun/core/language_model.py,sha256=Tzswu0hyXOQOZ3fZ_Mz_Cc0ei7tVj8rTay9jJEgM6mI,17510
+langfun/core/language_model.py,sha256=1_GO6oEm0wXnE7aRRLOdT-A4j_6YvRanS5oMgfobcIs,18331
 langfun/core/language_model_test.py,sha256=KvXXOr64TsSs3WkEALCLLZSlz09i7hBiHDOZ_8Eq8_o,13047
 langfun/core/memory.py,sha256=f-asN1F7Vehgdn_fK84v73GrEUOxRtaW934keutTKjk,2416
 langfun/core/message.py,sha256=QhvV9t5qaryPcruyxxcXi3gm9QDInkSldwTtK6sVJ3c,15734
@@ -46,9 +46,11 @@ langfun/core/eval/matching.py,sha256=aqNlYrlav7YmsB7rUlsdfoi1RLA5CYqn2RGPxRlPc78
 langfun/core/eval/matching_test.py,sha256=FFHYD7IDuKe5RMjkx74ksukiwUhO5a_SS340JaIPMws,4898
 langfun/core/eval/scoring.py,sha256=aKeanBJf1yO3Q9JEtgPWoiZk_3M_GiqwXVXX7x_g22w,6172
 langfun/core/eval/scoring_test.py,sha256=YH1cIxBWtfdKcAV9Fh10vLkV5J-gxk8b6nxW4Z2u5pk,4024
-langfun/core/llms/__init__.py,sha256=gROJ8AjMq_ebXFcEfsyzYGCS6NsGfzf9d43nLu_TIdw,2504
+langfun/core/llms/__init__.py,sha256=qIvFxup-A7PYL_2Fn7CvTzVNQ05413RKZwZpO5jrTiQ,2715
+langfun/core/llms/anthropic.py,sha256=Z3nER4Zc5dbREZa40RwPHY-JifTSQ_ZPSup31FFY8Lg,7305
+langfun/core/llms/anthropic_test.py,sha256=OuLDxeiPRdqsfKILS0R6jJLTRs3-1KCIotPPr7IbIDU,5502
 langfun/core/llms/fake.py,sha256=b-Xk5IPTbUt-elsyzd_i3n1tqzc_kgETXrEvgJruSMk,2824
-langfun/core/llms/fake_test.py,sha256=AThvNyhZbkpsn-YO798uLgqB6TSw5XP2SKpKvcXEytw,4188
+langfun/core/llms/fake_test.py,sha256=ZlDQgL41EX3eYTfBQNp2nB2LciqCmtoHgCsGvW4XhwI,4184
 langfun/core/llms/google_genai.py,sha256=n8zyJwh9UCTgb6-8LyvmjVNFGZQ4-zfzZ0ulkhHAnR8,8624
 langfun/core/llms/google_genai_test.py,sha256=_UcGTfl16-aDUlEWFC2W2F8y9jPUs53RBYA6MOCpGXw,7525
 langfun/core/llms/llama_cpp.py,sha256=Y_KkMUf3Xfac49koMUtUslKl3h-HWp3-ntq7Jaa3bdo,2385
@@ -97,8 +99,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.dev20240418.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.0.2.dev20240418.dist-info/METADATA,sha256=lZtyyTUeLg3CBgl4K0U82O_5YWUSh6TDpYHG893cXA8,3405
-langfun-0.0.2.dev20240418.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-langfun-0.0.2.dev20240418.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.0.2.dev20240418.dist-info/RECORD,,
+langfun-0.0.2.dev20240419.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.0.2.dev20240419.dist-info/METADATA,sha256=sDej42bUZ0DRsCLxy8bdXp-qTDeIGKoY5ZndIG7dKMM,3405
+langfun-0.0.2.dev20240419.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+langfun-0.0.2.dev20240419.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.0.2.dev20240419.dist-info/RECORD,,