langfun 0.1.2.dev202505130804__py3-none-any.whl → 0.1.2.dev202505140804__py3-none-any.whl

langfun/core/structured/querying_test.py

@@ -15,6 +15,7 @@
 
 import inspect
 import math
+import time
 from typing import Any
 import unittest
 
@@ -984,6 +985,19 @@ class LfQueryPythonV2Test(unittest.TestCase):
       ):
         querying.query('Compute 1 + 2', int)
 
+  def test_not_allowed_code(self):
+    lm = fake.StaticResponse(
+        """
+        class Foo:
+          pass
+        """
+    )
+    with self.assertRaisesRegex(
+        mapping.MappingError,
+        'Class definition is not allowed',
+    ):
+      querying.query('Compute 1 + 2', int, lm=lm)
+
   def test_autofix(self):
     lm = fake.StaticSequence([
         '=1',
@@ -1319,7 +1333,9 @@ class QueryInvocationTest(unittest.TestCase):
 
     self.assertEqual(queries[0].id, '123')
     self.assertTrue(queries[0].has_error)
-    self.assertIsInstance(queries[0].output, mapping.MappingError)
+    self.assertIsInstance(queries[0].error, pg.utils.ErrorInfo)
+    self.assertIn('MappingError', queries[0].error.tag)
+    self.assertIsNone(queries[0].output)
 
   def test_kwargs(self):
     lm = fake.StaticSequence([
@@ -1374,11 +1390,147 @@ class QueryInvocationTest(unittest.TestCase):
     mapping_example = queries[0].as_mapping_example()
     self.assertTrue(pg.eq(mapping_example.input, lf.Template('foo {{x}}', x=1)))
     self.assertEqual(mapping_example.schema.spec.cls, Activity)
-    self.assertIsInstance(mapping_example.output, mapping.MappingError)
+    self.assertEqual(mapping_example.output, 'Activity(description="hi"')
 
 
 class TrackQueriesTest(unittest.TestCase):
 
+  def test_query_without_schema(self):
+    lm = fake.StaticSequence([
+        'bar',
+    ])
+    with querying.track_queries() as queries:
+      querying.query('foo', lm=lm)
+    self.assertEqual(len(queries), 1)
+    self.assertEqual(queries[0].lm_response, 'bar')
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertEqual(queries[0].lm_request, 'foo')
+    self.assertIsNone(queries[0].schema)
+    self.assertEqual(queries[0].protocol, 'python')
+    self.assertEqual(queries[0].default, lf.RAISE_IF_HAS_ERROR)
+
+    self.assertEqual(queries[0].output, 'bar')
+    self.assertFalse(queries[0].has_error)
+    self.assertIsNone(queries[0].error)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
+  def test_query_with_schema(self):
+    lm = fake.StaticSequence([
+        'Activity(description="hi")',
+    ])
+    with querying.track_queries() as queries:
+      querying.query('foo', Activity, lm=lm)
+    self.assertEqual(len(queries), 1)
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertIn('foo', queries[0].lm_request.text)
+    self.assertIn('Please respond to ', queries[0].lm_request.text)
+    self.assertEqual(queries[0].schema.spec.cls, Activity)
+    self.assertEqual(queries[0].default, lf.RAISE_IF_HAS_ERROR)
+    self.assertTrue(queries[0].protocol.startswith('python:'))
+
+    self.assertTrue(pg.eq(queries[0].output, Activity(description='hi')))
+    self.assertFalse(queries[0].has_error)
+    self.assertIsNone(queries[0].error)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
+  def test_query_with_schema_and_default(self):
+    lm = fake.StaticSequence([
+        'Activity(description="hi")',
+    ])
+    with querying.track_queries() as queries:
+      querying.query('foo', Activity, default=None, lm=lm)
+    self.assertEqual(len(queries), 1)
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertIn('foo', queries[0].lm_request.text)
+    self.assertIn('Please respond to ', queries[0].lm_request.text)
+    self.assertEqual(queries[0].schema.spec.cls, Activity)
+    self.assertIsNone(queries[0].default)
+    self.assertTrue(queries[0].protocol.startswith('python:'))
+
+    self.assertTrue(pg.eq(queries[0].output, Activity(description='hi')))
+    self.assertFalse(queries[0].has_error)
+    self.assertIsNone(queries[0].error)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
+  def test_oop_error_for_query_with_schema(self):
+    lm = fake.StaticSequence([
+        'Activity(description="hi"',
+    ])
+    with (
+        self.assertRaises(mapping.MappingError),
+        querying.track_queries() as queries
+    ):
+      querying.query('foo', Activity, lm=lm)
+    self.assertEqual(len(queries), 1)
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertIn('foo', queries[0].lm_request.text)
+    self.assertIn('Please respond to ', queries[0].lm_request.text)
+    self.assertEqual(queries[0].schema.spec.cls, Activity)
+    self.assertEqual(queries[0].default, lf.RAISE_IF_HAS_ERROR)
+    self.assertTrue(queries[0].protocol.startswith('python:'))
+
+    self.assertIsNone(queries[0].output)
+    self.assertTrue(queries[0].has_error)
+    self.assertTrue(queries[0].has_oop_error)
+    self.assertIsNotNone(queries[0].error)
+    self.assertIn('MappingError', queries[0].error.tag)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
+  def test_oop_error_for_query_with_schema_and_default(self):
+    lm = fake.StaticSequence([
+        'Activity(description="hi"',
+    ])
+    with querying.track_queries() as queries:
+      querying.query('foo', Activity, default=1, lm=lm)
+
+    self.assertEqual(len(queries), 1)
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertIn('foo', queries[0].lm_request.text)
+    self.assertIn('Please respond to ', queries[0].lm_request.text)
+    self.assertEqual(queries[0].schema.spec.cls, Activity)
+    self.assertEqual(queries[0].default, 1)
+    self.assertTrue(queries[0].protocol.startswith('python:'))
+
+    self.assertEqual(queries[0].output, 1)
+    self.assertTrue(queries[0].has_error)
+    self.assertTrue(queries[0].has_oop_error)
+    self.assertIsNotNone(queries[0].error)
+    self.assertIn('MappingError', queries[0].error.tag)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
+  def test_lm_error_for_query_with_schema(self):
+    class BadLLM(fake.StaticResponse):
+      response = 'bad call'
+
+      def _sample(self, *args, **kwargs):
+        raise ValueError('bad LLM')
+
+    with (
+        self.assertRaises(ValueError),
+        querying.track_queries() as queries
+    ):
+      querying.query('foo', Activity, default=1, lm=BadLLM())
+
+    self.assertEqual(len(queries), 1)
+    self.assertTrue(pg.eq(queries[0].input, lf.Template('foo')))
+    self.assertIn('foo', queries[0].lm_request.text)
+    self.assertIn('Please respond to ', queries[0].lm_request.text)
+    self.assertEqual(queries[0].schema.spec.cls, Activity)
+    self.assertEqual(queries[0].default, 1)
+    self.assertTrue(queries[0].protocol.startswith('python:'))
+
+    self.assertIsNone(queries[0].output)
+    self.assertTrue(queries[0].has_error)
+    self.assertIsNotNone(queries[0].error)
+    self.assertIn('ValueError', queries[0].error.tag)
+    self.assertIsNotNone(queries[0].end_time)
+    self.assertIsNotNone(queries[0].usage_summary)
+
   def test_include_child_scopes(self):
     lm = fake.StaticSequence([
         'bar',
@@ -1413,6 +1565,94 @@ class TrackQueriesTest(unittest.TestCase):
     self.assertEqual(len(child_queries), 1)
     self.assertIs(child_queries[0], queries[1])
 
+  def test_callbacks(self):
+    lm = fake.StaticSequence([
+        'bar',
+    ])
+    state = {}
+    def start_callabck(query):
+      self.assertFalse(query.is_completed)
+      self.assertIsNone(query.end_time)
+      elapse1 = query.elapse
+      self.assertGreater(elapse1, 0)
+      time.sleep(0.1)
+      self.assertGreater(query.elapse, elapse1)
+      self.assertIsNotNone(query.usage_summary)
+      self.assertEqual(query.usage_summary.total.num_requests, 0)
+      self.assertIsNone(query.lm_response)
+      self.assertIsNone(query.output)
+      self.assertIsNone(query.error)
+      state['start'] = query
+
+    def end_callback(query):
+      self.assertTrue(query.is_completed)
+      self.assertIsNotNone(query.end_time)
+      self.assertIsNotNone(query.usage_summary)
+      self.assertEqual(query.usage_summary.total.num_requests, 1)
+      self.assertIsNotNone(query.lm_response)
+      self.assertIsNotNone(query.output)
+      self.assertIsNone(query.error)
+      state['end'] = query
+
+    with querying.track_queries(
+        start_callabck=start_callabck, end_callabck=end_callback
+    ) as queries:
+      querying.query('foo', lm=lm)
+    self.assertIs(state['start'], queries[0])
+    self.assertIs(state['end'], queries[0])
+
+  def test_callbacks_with_error(self):
+    lm = fake.StaticSequence([
+        'bar',
+    ])
+    state = {}
+    def start_callabck(query):
+      self.assertFalse(query.is_completed)
+      self.assertIsNone(query.end_time)
+      self.assertIsNotNone(query.usage_summary)
+      self.assertEqual(query.usage_summary.total.num_requests, 0)
+      self.assertIsNone(query.lm_response)
+      self.assertIsNone(query.output)
+      self.assertIsNone(query.error)
+      state['start'] = query
+
+    def end_callback(query):
+      self.assertTrue(query.is_completed)
+      self.assertIsNotNone(query.end_time)
+      self.assertIsNotNone(query.usage_summary)
+      self.assertEqual(query.usage_summary.total.num_requests, 1)
+      self.assertIsNotNone(query.lm_response)
+      self.assertIsNone(query.output)
+      self.assertIsNotNone(query.error)
+      state['end'] = query
+
+    with self.assertRaises(mapping.MappingError):
+      with querying.track_queries(
+          start_callabck=start_callabck, end_callabck=end_callback
+      ) as queries:
+        querying.query('foo', int, lm=lm)
+    self.assertIs(state['start'], queries[0])
+    self.assertIs(state['end'], queries[0])
+
+  def test_track_with_autofix(self):
+    lm = fake.StaticSequence([
+        '=1',
+        inspect.cleandoc("""
+            CorrectedCode(
+                corrected_code='1',
+            )
+            """),
+    ])
+    with querying.track_queries() as queries:
+      querying.query('foo', int, lm=lm, autofix=1)
+    self.assertEqual(len(queries), 2)
+    self.assertTrue(queries[0].has_error)
+    self.assertTrue(queries[0].has_oop_error)
+    self.assertIsNone(queries[0].output)
+    self.assertFalse(queries[1].has_error)
+    self.assertEqual(queries[1].output.__class__.__name__, 'CorrectedCode')
+    self.assertEqual(queries[1].output.corrected_code, '1')
+
   def test_exclude_child_scopes(self):
     lm = fake.StaticSequence([
         'bar',

langfun/core/structured/schema.py

@@ -722,6 +722,9 @@ class ValuePythonRepr(ValueRepr):
       schema: Schema | None = None,
       *,
       additional_context: dict[str, Type[Any]] | None = None,
+      permission: pg.coding.CodePermission = (
+          pg.coding.CodePermission.ASSIGN | pg.coding.CodePermission.CALL
+      ),
       autofix=0,
       autofix_lm: lf.LanguageModel = lf.contextual(),
       **kwargs,
@@ -737,6 +740,7 @@ class ValuePythonRepr(ValueRepr):
         global_vars=global_vars,
         autofix=autofix,
         autofix_lm=autofix_lm,
+        permission=permission,
     )
 
 
@@ -744,6 +748,9 @@ def structure_from_python(
     code: str,
     *,
     global_vars: dict[str, Any] | None = None,
+    permission: pg.coding.CodePermission = (
+        pg.coding.CodePermission.ASSIGN | pg.coding.CodePermission.CALL
+    ),
     autofix=0,
     autofix_lm: lf.LanguageModel = lf.contextual(),
 ) -> Any:
@@ -769,6 +776,7 @@ def structure_from_python(
       sandbox=False,
       max_attempts=autofix,
       lm=autofix_lm,
+      permission=permission,
   )
 
 

langfun/core/structured/schema_generation.py

@@ -27,6 +27,7 @@ class GenerateClass(mapping.Mapping):
   input_title = 'GENERATION_CONTEXT'
   context_title = 'CLASS_NAME'
   output_title = 'OUTPUT_CLASS'
+  permission = pg.coding.CodePermission.ALL
 
   preamble: lf.Template = lf.Template("""
       Help generate a class based on the last {{ context_title }} and {{ input_title }}.

langfun/core/structured/schema_test.py

@@ -149,7 +149,8 @@ class SchemaTest(unittest.TestCase):
         class C(B):
           pass
         """,
-        global_vars=dict(B=B)
+        global_vars=dict(B=B),
+        permission=pg.coding.CodePermission.ALL,
     )
     self.assertEqual(v.__module__, 'builtins')
     self.assertEqual(schema.class_dependencies(), [Foo, A, Bar, X, B])
@@ -175,7 +176,8 @@ class SchemaTest(unittest.TestCase):
         class CC(BB):
           pass
         """,
-        global_vars=dict(BB=BB)
+        global_vars=dict(BB=BB),
+        permission=pg.coding.CodePermission.ALL,
     )
     self.assertEqual(v.__module__, 'builtins')
     schema = schema_lib.Schema([AA])
@@ -818,7 +820,8 @@ class ValuePythonReprTest(unittest.TestCase):
                   x: Dict[str, Any]
                   y: Optional[Sequence[str]]
                   z: Union[int, List[int], Tuple[int]]
-                """
+                """,
+                permission=pg.coding.CodePermission.ALL,
             )
         )
     )

{langfun-0.1.2.dev202505130804.dist-info → langfun-0.1.2.dev202505140804.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202505130804
+Version: 0.1.2.dev202505140804
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202505130804.dist-info → langfun-0.1.2.dev202505140804.dist-info}/RECORD

@@ -4,13 +4,13 @@ langfun/core/component.py,sha256=g1kQM0bryYYYWVDrSMnHfc74wIBbpfe5_B3s-UIP5GE,302
 langfun/core/component_test.py,sha256=0CxTgjAud3aj8wBauFhG2FHDqrxCTl4OI4gzQTad-40,9254
 langfun/core/concurrent.py,sha256=zY-pXqlGqss_GI20tM1gXvyW8QepVPUuFNmutcIdhbI,32760
 langfun/core/concurrent_test.py,sha256=roMFze0EKuyPbmG6DZzz8K8VGsZwWzc0F1uJZTFROC4,17572
-langfun/core/console.py,sha256=V_mOiFi9oGh8gLsUeR56pdFDkuvYOpvQt7DY1KUTWTA,2535
+langfun/core/console.py,sha256=cLQEf84aDxItA9fStJV22xJch0TqFLNf9hLqwJ0RHmU,2652
 langfun/core/console_test.py,sha256=pBOcuNMJdVELywvroptfcRtJMsegMm3wSlHAL2TdxVk,1679
 langfun/core/langfunc.py,sha256=G50YgoVZ0y1GFw2ev41MlOqr6qa8YakbvNC0h_E0PiA,11140
 langfun/core/langfunc_test.py,sha256=CDn-gJCa5EnjN7cotAVCfSCbuzddq2o-HzEt7kV8HbY,8882
-langfun/core/language_model.py,sha256=dw81qgdl-zn-qOIbRMSurtAmmpiwr2sSYlSlW19nUw0,47829
+langfun/core/language_model.py,sha256=GCvbu749TviZyLQSNunO0rKeDAb7E_6G4rzqQJerN_E,47913
 langfun/core/language_model_test.py,sha256=iA5uo7rIj2jAtCYzMzhyNg1fWqE2Onn60bOO58q72C0,36454
-langfun/core/logging.py,sha256=ypjSwGzQpIhadewEKkIH5VWS55rfU4e6mlni41PMHlw,9116
+langfun/core/logging.py,sha256=jwPamwFYozrs3Tsds8xXG23PhfqODTZ2Au7poTH3yxE,9121
 langfun/core/logging_test.py,sha256=vbVGOQxwMmVSiFfbt2897gUt-8nqDpV64jCAeUG_q5U,6924
 langfun/core/memory.py,sha256=vyXVvfvSdLLJAzdIupnbn3k26OgclCx-OJ7gddS5e1Y,2070
 langfun/core/message.py,sha256=qUJZ9NfrlYG3aU_K2ud236gdTnvZ7Qw2T4pv4hI9ivg,32817
@@ -26,13 +26,13 @@ langfun/core/subscription_test.py,sha256=Y4ZdbZEwm83YNZBxHff0QR4QUa4rdaNXA3_jfIc
 langfun/core/template.py,sha256=jNhYSrbLIn9kZOa03w5QZbyjgfnzJzE_ZrrMvvWY4t4,24929
 langfun/core/template_test.py,sha256=AQv_m9qE93WxhEhSlm1xaBgB4hu0UVtA53dljngkUW0,17090
 langfun/core/agentic/__init__.py,sha256=qR3jlfUO4rhIoYdRDLz-d22YZf3FvU4FW88vsjiGDQQ,1224
-langfun/core/agentic/action.py,sha256=jxjW4vkJs3p-AYb83P0AVnmE93Vx7z0QoFsm40NQ65k,46853
-langfun/core/agentic/action_eval.py,sha256=JXhS5qEjWu9EZ0chDsjWxCqPAV26PUCBijtUYxiDeO4,4975
+langfun/core/agentic/action.py,sha256=G2HwLr8SZe0fpqGBu5obuzMz3EDMl-xFJab5myQOBv4,49571
+langfun/core/agentic/action_eval.py,sha256=YTilyUEkJl_8FVMgdfO17PurWWaEJ6oA15CuefJJRLk,4887
 langfun/core/agentic/action_eval_test.py,sha256=7AkOwNbUX-ZgR1R0a7bvUZ5abNTUV7blf_8Mnrwb-II,2811
 langfun/core/agentic/action_test.py,sha256=wrx7_JUyL6EXhJeUqmPkPyIwOAh_KwTOWhSRgv2wYWo,15613
 langfun/core/coding/__init__.py,sha256=5utju_fwEsImaiftx4oXKl9FAM8p281k8-Esdh_-m1w,835
 langfun/core/coding/python/__init__.py,sha256=4ByknuoNU-mOIHwHKnTtmo6oD64oMFtlqPlYWmA5Wic,1736
-langfun/core/coding/python/correction.py,sha256=7zBedlhQKMPA4cfchUMxAOFl6Zl5RqCyllRHGWys40s,7092
+langfun/core/coding/python/correction.py,sha256=4PD76Xfv36Xrm8Ji3-GgGDNImtcDqWfMw3z6ircJMlM,7285
 langfun/core/coding/python/correction_test.py,sha256=sie88lAbsV15bvkRcYC88pgToybZYXI32Xmg_ym5V1A,4175
 langfun/core/coding/python/execution.py,sha256=tsXnJ-11RqNDro0C-6LwbHkqPuNVJ_cLxAq8-C5Wz20,4442
 langfun/core/coding/python/execution_test.py,sha256=NynCGNP0gZ08fqmmQIJjJu6HmhkNOSkgWUXUCNQ0_yg,5990
@@ -133,16 +133,16 @@ langfun/core/structured/description.py,sha256=6BztYOiucPkF4CrTQtPLPJo1gN2dwnKmaJ
 langfun/core/structured/description_test.py,sha256=UxaXnKKP7TnyPDPUyf3U-zPE0TvLlIP6DGr8thjcePw,7365
 langfun/core/structured/function_generation.py,sha256=g7AOR_e8HxFU6n6Df750aGkgMgV1KExLZMAz0yd5Agg,8555
 langfun/core/structured/function_generation_test.py,sha256=LaXYDXf9GlqUrR6v_gtmK_H4kxzonmU7SYbn7XXMgjU,12128
-langfun/core/structured/mapping.py,sha256=gxdcYQP9yqbDRtiJQ1RRAOrKHiCr0h6xBYLCRKE4I3c,13723
+langfun/core/structured/mapping.py,sha256=iraHpcEeF_iuEX2eoTsLGwTHHvxqp2gNDjoMf98l0Kk,13941
 langfun/core/structured/mapping_test.py,sha256=OntYvfDitAf0tAnzQty3YS90vyEn6FY1Mi93r_ViEk8,9594
 langfun/core/structured/parsing.py,sha256=MGvI7ypXlwfzr5XB8_TFU9Ei0_5reYqkWkv64eAy0EA,12015
 langfun/core/structured/parsing_test.py,sha256=V8Cj1tJK4Lxv_b0YQj6-2hzXZgnYNBa2JR7rOLRBKoQ,22346
-langfun/core/structured/querying.py,sha256=v-C8cU4LNFPwVSVgfO5PFyYxKCTHHh6SdbaR5V5MKKs,30938
-langfun/core/structured/querying_test.py,sha256=6jN3oOSpVEBIlISrCUJtZfY6sBHahF_EBRUEhNNlzW8,40797
-langfun/core/structured/schema.py,sha256=UTonddBx3hVr0Zhm_38jqd8khTSXWy-bkk8l1YOUdLA,28797
-langfun/core/structured/schema_generation.py,sha256=3AcuKvv3VOtKY5zMVqODrxfOuDxzoZtGeBxHlOWDOWw,5308
+langfun/core/structured/querying.py,sha256=7QvM4TS57O5kDCty6H8leWXfZxcN5ugWV-4bmdDABC0,38006
+langfun/core/structured/querying_test.py,sha256=AXIVamBeKvby10zogjZl_wqtBopbpud-NNEZlqfLyqY,49766
+langfun/core/structured/schema.py,sha256=r_ewdRMsALVOdnvGSeYBcz2-VJ_3_nMxY4GtzUHCYUU,29111
+langfun/core/structured/schema_generation.py,sha256=pEWeTd8tQWYnEHukas6GVl4uGerLsQ2aNybtnm4Qgxc,5352
 langfun/core/structured/schema_generation_test.py,sha256=RM9s71kMNg2jTePwInkiW9fK1ACN37eyPeF8OII-0zw,2950
-langfun/core/structured/schema_test.py,sha256=pW0uoriwE_F6VH2DlAopeXlltcLBP_xnf8DA7QhVroc,26409
+langfun/core/structured/schema_test.py,sha256=H42ZZdPi8CIv7WzrnXwMwQQaPQxlmDSY31pfqQs-Xqw,26567
 langfun/core/structured/scoring.py,sha256=Y7Jqs5VVjUQLF_9Z1uIY_dw5zasv2FF52Cz-cxGMsro,5857
 langfun/core/structured/scoring_test.py,sha256=QvlwDAzwuamKL5tCotm1L3Sx0cs3idoNK4aIEhaO4Yk,2272
 langfun/core/structured/tokenization.py,sha256=-b4_693quHeYn2AqndwucuXNmhd5NVXVTU3mmDane98,2189
@@ -156,8 +156,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=Ot__1P1M8oJfoTp-M9-PQ6HUXqZKyMwvZ5f7yQ3yfyM,2326
-langfun-0.1.2.dev202505130804.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.1.2.dev202505130804.dist-info/METADATA,sha256=i-rMyyw0gOG8YgoQmvMEXZUGF9OPziH59QA8SJpLS4g,8178
-langfun-0.1.2.dev202505130804.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-langfun-0.1.2.dev202505130804.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.1.2.dev202505130804.dist-info/RECORD,,
+langfun-0.1.2.dev202505140804.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.1.2.dev202505140804.dist-info/METADATA,sha256=sg9BNWj3ZTxdvhCni6lzMwhy9PJwBSa4tSv_saN6RQ0,8178
+langfun-0.1.2.dev202505140804.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+langfun-0.1.2.dev202505140804.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.1.2.dev202505140804.dist-info/RECORD,,