langfun 0.0.2.dev20240104__tar.gz → 0.0.2.dev20240106__tar.gz

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240104
+Version: 0.0.2.dev20240106
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: openai==0.27.2
-Requires-Dist: pyglove>=0.4.4.dev20231213
+Requires-Dist: pyglove>=0.4.5.dev20240105
 Requires-Dist: requests>=2.31.0
 Requires-Dist: termcolor==1.1.0
 Requires-Dist: tqdm>=4.64.1

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/coding/python/correction.py

@@ -107,7 +107,7 @@ def run_with_correction(
 
   examples = examples or DEFAULT_CODE_CORRECTION_EXAMPLES
   examples = [  # pylint: disable=g-complex-comprehension
-      completion.completion_example(
+      completion.mapping.MappingExample(
           CodeCorrection.partial(ex.latest_code, ex.correction_history),
           ex,
       )

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/coding/python/generation.py

@@ -21,12 +21,12 @@ import pyglove as pg
 
 
 class PythonCode(pg.Object):
-  """Symbolic class for Python code."""
+  """Symbolic class for Python code.
 
-  source: Annotated[
-      str,
-      'Source code.'
-  ]
+  The source code will be directly passed into eval() for execution. The value
+  of the last expression of the source will be returned.
+  """
+  source: Annotated[str, 'Source code.']
 
   _TLS_AUTO_RUN = '__auto_run__'
 
@@ -135,18 +135,21 @@ class PythonCode(pg.Object):
         global_vars=global_vars,
         sandbox=sandbox,
         timeout=timeout,
-        outputs_intermediate=True)
+        outputs_intermediate=True,
+    )
 
 
 class PythonFunction(pg.Object):
-  """Generated Python function via source code."""
+  """Generated Python function via source code.
+
+  The source code will be directly passed into eval() for execution and the
+  output of the function will be returned.
+  """
+
   name: str
   args: dict[str, str]
   returns: str
-  source: Annotated[
-      str,
-      'Source code for the Python function. '
-  ]
+  source: Annotated[str, 'Source code for the Python function. ']
 
   def _on_bound(self):
     super()._on_bound()

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/eval/base.py

@@ -634,7 +634,8 @@ class Evaluation(Evaluable):
           'examples will be used for parsing. For "query" and "complete", it '
           'must be provided, and the fewshot examples will be used directly '
           'for prompting. Here are the example code on how the '
-          'functors should be defined:' + inspect.cleandoc("""
+          'functors should be defined:'
+          + inspect.cleandoc("""
               ```
               @pg.functor()
               def solution():
@@ -648,9 +649,9 @@ class Evaluation(Evaluable):
                   final_answer: int
                 return Solution, [
                     lf.structured.MappingExample(
-                        nl_text='Compute 1 + 2',
-                        schema=Solution,
-                        value=Solution(3))
+                        input='Compute 1 + 2',
+                        output=Solution(3),
+                        schema=Solution)
                 ]
               ```
               """)
@@ -832,16 +833,13 @@ class Evaluation(Evaluable):
 
     completion_examples = []
     for ex in fewshot_examples:
-      if ex.nl_context is not None:
-        init_args = dict(ex.value.sym_init_args)
-        example_cls = ex.value.__class__
-        self._maybe_adjust_schema_for_completion(example_cls)
-        ex = lf.structured.MappingExample(
-            value=lf.structured.mapping.Pair(
-                left=example_cls.partial(ex.nl_context),
-                right=example_cls(ex.nl_context, **init_args),
-            )
-        )
+      example_cls = ex.output.__class__
+      self._maybe_adjust_schema_for_completion(example_cls)
+      ex = lf.structured.MappingExample(
+          context=ex.context,
+          input=example_cls.partial(ex.input),
+          output=example_cls(ex.input, **ex.output.sym_init_args),
+      )
       completion_examples.append(ex)
     return completion_examples
 

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/eval/base_test.py

@@ -45,9 +45,9 @@ def answer_schema():
 def answer_schema_with_fewshot_examples():
   return Solution, [
       lf_structured.MappingExample(
-          nl_text='The result of one plus two',
+          input='The result of one plus two',
+          output=Solution(3),
           schema=Solution,
-          value=Solution(3)
       )
   ]
 
@@ -120,10 +120,11 @@ class EvaluationTest(unittest.TestCase):
             s.fewshot_examples,
             [
                 lf_structured.MappingExample(
-                    nl_text='The result of one plus two',
+                    input='The result of one plus two',
+                    output=Solution(3),
                     schema=Solution,
-                    value=Solution(3))
-            ]
+                )
+            ],
         )
     )
 
@@ -137,9 +138,9 @@ class EvaluationTest(unittest.TestCase):
 
       return Solution1, [
           lf.structured.MappingExample(
-              nl_context='The result of one plus two',
+              input='The result of one plus two',
+              output=Solution1(3),
               schema=Solution1,
-              value=Solution1(3)
           )
       ]
 
@@ -159,13 +160,12 @@ class EvaluationTest(unittest.TestCase):
             fewshot_examples,
             [
                 lf.structured.MappingExample(
-                    value=lf.structured.mapping.Pair(
-                        left=solution_cls.partial(
-                            question='The result of one plus two'),
-                        right=solution_cls('The result of one plus two', 3),
-                    )
+                    input=solution_cls.partial(
+                        question='The result of one plus two'
+                    ),
+                    output=solution_cls('The result of one plus two', 3),
                 )
-            ]
+            ],
         )
     )
 

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/natural_language.py

@@ -26,16 +26,13 @@ class NaturalLanguageFormattable(pg.Formattable):
 
   def format(
       self,
-      compact: bool = False,
-      verbose: bool = True,
-      root_indent: int = 0,
+      *args,
+      natural_language: bool = False,
       **kwargs
   ) -> str:
-    if compact:
-      # For `repr(x)`, which returns the symbolic representation of
-      # current object.
-      return super().format(compact, verbose, root_indent, **kwargs)
-    else:
-      # For `str(x)`, which returns the natural language representation of
-      # current object.
+    if natural_language:
       return self.natural_language_format()
+    return super().format(*args, **kwargs)
+
+  def __str__(self):
+    return self.natural_language_format()

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/natural_language_test.py

@@ -16,6 +16,7 @@ import unittest
 
 from langfun.core import component
 from langfun.core import natural_language as nl
+import pyglove as pg
 
 
 class NaturalLanguageFormattableTest(unittest.TestCase):
@@ -31,6 +32,8 @@ class NaturalLanguageFormattableTest(unittest.TestCase):
 
     a = A(1, 'abc')
     self.assertEqual(repr(a), 'A(x=1, y=\'abc\')')
+    with pg.object_utils.repr_format(natural_language=True):
+      self.assertEqual(repr(a), "A simple object with 1 and 'abc'.")
     self.assertEqual(str(a), "A simple object with 1 and 'abc'.")
 
 

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/structured/__init__.py

@@ -47,11 +47,6 @@ from langfun.core.structured.schema import value_repr
 from langfun.core.structured.mapping import Mapping
 from langfun.core.structured.mapping import MappingExample
 
-# Mappings of between different forms of content.
-from langfun.core.structured.mapping import NaturalLanguageToStructure
-from langfun.core.structured.mapping import StructureToNaturalLanguage
-from langfun.core.structured.mapping import StructureToStructure
-
 from langfun.core.structured.parsing import ParseStructure
 from langfun.core.structured.parsing import ParseStructureJson
 from langfun.core.structured.parsing import ParseStructurePython
@@ -74,8 +69,6 @@ from langfun.core.structured.completion import complete
 from langfun.core.structured.parsing import DEFAULT_PARSE_EXAMPLES
 from langfun.core.structured.description import DEFAULT_DESCRIBE_EXAMPLES
 
-from langfun.core.structured.completion import completion_example
-
 # Default examples.
 
 

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/structured/completion.py

@@ -11,9 +11,9 @@
 # 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.
-"""Structure-to-structure mappings."""
+"""Symbolic completion."""
 
-from typing import Any
+from typing import Annotated, Any, Type
 
 import langfun.core as lf
 from langfun.core.structured import mapping
@@ -21,53 +21,37 @@ from langfun.core.structured import schema as schema_lib
 import pyglove as pg
 
 
-class CompleteStructure(mapping.StructureToStructure):
+class CompleteStructure(mapping.Mapping):
   """Complete structure by filling the missing fields."""
 
+  input: Annotated[
+      pg.Symbolic, 'A symbolic object with `lf.MISSING` values to complete.'
+  ] = lf.contextual()
+
   mapping_template = lf.Template("""
-      {{ input_value_title }}:
-      {{ value_str(example.value.left) | indent(2, True) }}
+      {{ input_title }}:
+      {{ example.input_repr() | indent(2, True) }}
 
-      {%- if missing_type_dependencies(example.value.left) %}
+      {%- if missing_type_dependencies(example.input) %}
 
-      {{ type_definitions_title }}:
-      {{ type_definitions_str(example.value.left) | indent(2, True) }}
+      {{ schema_title }}:
+      {{ class_defs_repr(example.input) | indent(2, True) }}
       {%- endif %}
-      {%- if has_modalities(example.value.left) %}
+      {%- if has_modalities(example.input) %}
 
       {{ modality_refs_title }}:
-      {{ modality_refs_str(example.value.left) | indent(2, True) }}
+      {{ modality_refs_repr(example.input) | indent(2, True) }}
       {%- endif %}
 
-      {{ output_value_title }}:
-      {%- if example.value.has_right %}
-      {{ value_str(example.value.right) | indent(2, True) }}
+      {{ output_title }}:
+      {%- if example.has_output %}
+      {{ example.output_repr() | indent(2, True) }}
       {% endif -%}
       """)
 
-  @property
-  def mapping_request(self) -> mapping.MappingExample:
-    return mapping.MappingExample(
-        nl_context=None,
-        nl_text=None,
-        schema=self.input_value.__class__,
-        value=mapping.Pair(
-            left=pg.Ref(self.input_value), right=schema_lib.MISSING
-        ),
-    )
-
-  def _on_bound(self):
-    super()._on_bound()
-    if self.examples:
-      for example in self.examples:
-        if not isinstance(example.value, mapping.Pair):
-          raise ValueError(
-              'The value of example must be a `lf.structured.Pair` object. '
-              f'Encountered: { example.value }.'
-          )
-
-  input_value_title = 'INPUT_OBJECT'
-  output_value_title = 'OUTPUT_OBJECT'
+  input_title = 'INPUT_OBJECT'
+  output_title = 'OUTPUT_OBJECT'
+  schema_title = 'CLASS_DEFINITIONS'
 
   preamble = lf.LangFunc(
       """
@@ -77,7 +61,7 @@ class CompleteStructure(mapping.StructureToStructure):
       1. Each MISSING field contains a Python annotation, please fill the value based on the annotation.
       2. Classes for the MISSING fields are defined under CLASS_DEFINITIONS.
 
-      {{input_value_title}}:
+      {{input_title}}:
         ```python
         Answer(
           question='1 + 1 =',
@@ -85,7 +69,7 @@ class CompleteStructure(mapping.StructureToStructure):
         )
         ```
 
-      {{output_value_title}}:
+      {{output_title}}:
         ```python
         Answer(
           question='1 + 1 =',
@@ -93,16 +77,62 @@ class CompleteStructure(mapping.StructureToStructure):
         )
         ```
       """,
-      input_value_title=input_value_title,
-      output_value_title=output_value_title,
+      input_title=input_title,
+      output_title=output_title,
   )
 
-  # NOTE(daiyip): Set the input path of the transform to root, so this transform
-  # could access the input via the `message.result` field.
-  input_path = ''
+  @property
+  def mapping_request(self) -> mapping.MappingExample:
+    """Returns a MappingExample as the mapping request."""
+    return mapping.MappingExample(
+        input=pg.Ref(self.input),
+        # Use the schema of input object.
+        schema=pg.Ref(schema_lib.Schema.from_value(self.input.__class__)),
+        context=self.context,
+    )
+
+  def transform_input(self, lm_input: lf.Message) -> lf.Message:
+    if not pg.contains(self.input, type=schema_lib.Missing):
+      raise ValueError(
+          'The input of `lf.complete` must contain a least one '
+          f'missing value. Encountered: {self.input}.'
+      )
+
+    # Find modalities to fill the input message.
+    modalities = self.modalities(self.input)
+    modalities.update(
+        self.modalities(self.examples, root_path=pg.KeyPath('examples'))
+    )
+    if modalities:
+      lm_input.metadata.update(pg.object_utils.canonicalize(modalities))
+    return lm_input
+
+  def missing_type_dependencies(self, value: Any) -> list[Type[Any]]:
+    value_specs = tuple(
+        [v.value_spec for v in schema_lib.Missing.find_missing(value).values()]
+    )
+    return schema_lib.class_dependencies(value_specs, include_subclasses=True)
+
+  def class_defs_repr(self, value: Any) -> str | None:
+    return schema_lib.class_definitions(
+        self.missing_type_dependencies(value), markdown=True
+    )
+
+  def postprocess_result(self, result: Any) -> Any:
+    """Postprocess result."""
+    # Try restore modality objects from the input value to output value.
+    modalities = self.modalities(self.input)
+    if modalities:
+      result.rebind(modalities)
+    return result
 
   def globals(self):
     context = super().globals()
+
+    # Add class dependencies from the input value to the globals.
+    classes = schema_lib.class_dependencies(self.input)
+    context.update({cls.__name__: cls for cls in classes})
+
     # NOTE(daiyip): since `lf.complete` could have fields of Any type, which
     # could be user provided objects. For LLMs to restores these objects, we
     # need to expose their types to the code evaluation context.
@@ -117,15 +147,10 @@ class CompleteStructure(mapping.StructureToStructure):
       if isinstance(v, pg.Object):
         cls = v.__class__
         context[cls.__name__] = cls
-    pg.traverse(self.input_value, _visit)
+    pg.traverse(self.input, _visit)
     return context
 
 
-def completion_example(left: Any, right: Any) -> mapping.MappingExample:
-  """Makes a mapping example for completion."""
-  return mapping.MappingExample(value=mapping.Pair(left=left, right=right))
-
-
 def complete(
     input_value: pg.Symbolic,
     default: Any = lf.RAISE_IF_HAS_ERROR,
@@ -200,5 +225,5 @@ def complete(
   context.update(kwargs)
 
   with t.override(**context):
-    output = t(input_value=schema_lib.mark_missing(input_value))
+    output = t(input=schema_lib.mark_missing(input_value))
   return output if returns_message else output.result

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/structured/completion_test.py

@@ -59,7 +59,7 @@ class CompleteStructureTest(unittest.TestCase):
         )
     )
     self.assertEqual(
-        l.render(input_value=input_value).text,
+        l.render(input=input_value).text,
         inspect.cleandoc("""
             Please generate the OUTPUT_OBJECT by completing the MISSING fields from the last INPUT_OBJECT.
 
@@ -133,7 +133,7 @@ class CompleteStructureTest(unittest.TestCase):
         )
     )
     self.assertEqual(
-        l.render(input_value=input_value).text,
+        l.render(input=input_value).text,
         inspect.cleandoc("""
             Please generate the OUTPUT_OBJECT by completing the MISSING fields from the last INPUT_OBJECT.
 
@@ -213,7 +213,7 @@ class CompleteStructureTest(unittest.TestCase):
         )
     )
     self.assertEqual(
-        l.render(input_value=input_value).text,
+        l.render(input=input_value).text,
         inspect.cleandoc("""
           Please generate the OUTPUT_OBJECT by completing the MISSING fields from the last INPUT_OBJECT.
 
@@ -410,15 +410,13 @@ class CompleteStructureTest(unittest.TestCase):
     l = completion.CompleteStructure(
         examples=[
             mapping.MappingExample(
-                value=mapping.Pair(
-                    left=Animal.partial(
-                        modalities.Image.from_bytes(b'image_of_rabbit')
-                    ),
-                    right=Animal(
-                        modalities.Image.from_bytes(b'image_of_rabbit'),
-                        'rabbit',
-                    ),
-                )
+                input=Animal.partial(
+                    modalities.Image.from_bytes(b'image_of_rabbit')
+                ),
+                output=Animal(
+                    modalities.Image.from_bytes(b'image_of_rabbit'),
+                    'rabbit',
+                ),
             )
         ]
     )
@@ -427,7 +425,8 @@ class CompleteStructureTest(unittest.TestCase):
             modalities.Image.from_bytes(b'image_of_elephant'),
         )
     )
-    lm_input = l.render(input_value=input_value)
+    lm_input = l.render(input=input_value)
+    self.maxDiff = None
     self.assertEqual(
         lm_input.text,
         inspect.cleandoc("""
@@ -463,9 +462,9 @@ class CompleteStructureTest(unittest.TestCase):
               )
               ```
 
-            MODALITY_REFS:
+            MODALITY_REFERENCES:
               {
-                'image': {{examples[0].value.left.image}}
+                'image': {{examples[0].input.image}}
               }
 
             OUTPUT_OBJECT:
@@ -489,7 +488,7 @@ class CompleteStructureTest(unittest.TestCase):
               )
               ```
 
-            MODALITY_REFS:
+            MODALITY_REFERENCES:
               {
                 'image': {{image}}
               }
@@ -504,28 +503,20 @@ class CompleteStructureTest(unittest.TestCase):
                 'image': lm_input.get('image'),
             },
             {
-                'examples': [
-                    {
-                        'value': {
-                            'left': {
-                                'image': modalities.Image.from_bytes(
-                                    b'image_of_rabbit'
-                                )
-                            },
-                            'right': {
-                                'image': modalities.Image.from_bytes(
-                                    b'image_of_rabbit'
-                                )
-                            },
-                        }
-                    }
-                ],
+                'examples': [{
+                    'input': {
+                        'image': modalities.Image.from_bytes(b'image_of_rabbit')
+                    },
+                    'output': {
+                        'image': modalities.Image.from_bytes(b'image_of_rabbit')
+                    },
+                }],
                 'image': modalities.Image.from_bytes(b'image_of_elephant'),
             },
         )
     )
     lm_output = l(
-        input_value=input_value,
+        input=input_value,
         lm=fake.StaticResponse(inspect.cleandoc("""
             ```python
             Animal(
@@ -595,9 +586,11 @@ class CompleteStructureTest(unittest.TestCase):
     with self.assertRaises(IndexError):
       completion.complete(Activity.partial(), lm=lm)
 
-  def test_bad_init(self):
-    with self.assertRaisesRegex(ValueError, '.*must be.*Pair'):
-      completion.CompleteStructure(examples=[mapping.MappingExample(value=1)])
+  def test_bad_call(self):
+    with self.assertRaisesRegex(
+        ValueError, '.*must contain a least .* missing'
+    ):
+      completion.complete(Activity('foo'), lm=fake.StaticResponse(''))
 
   def test_bad_transform(self):
     with lf.context(

{langfun-0.0.2.dev20240104 → langfun-0.0.2.dev20240106}/langfun/core/structured/description.py

@@ -11,7 +11,7 @@
 # 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.
-"""Structured value to natural language."""
+"""Symbolic description."""
 
 import inspect
 from typing import Any, Literal
@@ -22,11 +22,15 @@ import pyglove as pg
 
 
 @pg.use_init_args(['examples'])
-class DescribeStructure(mapping.StructureToNaturalLanguage):
+class DescribeStructure(mapping.Mapping):
   """Describe a structured value in natural language."""
 
+  input_title = 'PYTHON_OBJECT'
+  context_title = 'CONTEXT_FOR_DESCRIPTION'
+  output_title = 'NATURAL_LANGUAGE_TEXT'
+
   preamble = """
-      Please help describe {{ value_title }} in natural language.
+      Please help describe {{ input_title }} in natural language.
 
       INSTRUCTIONS:
         1. Do not add details which are not present in the object.
@@ -103,7 +107,7 @@ def describe(
   if lm is not None:
     kwargs['lm'] = lm
   return DescribeStructure(examples)(
-      input_value=value, nl_context=context, **kwargs
+      input=value, context=context, **kwargs
   ).text
 
 
@@ -130,16 +134,8 @@ class _Country(pg.Object):
 
 DEFAULT_DESCRIBE_EXAMPLES: list[mapping.MappingExample] = [
     mapping.MappingExample(
-        nl_context='Brief intro to United States',
-        nl_text=inspect.cleandoc("""
-            The United States of America is a country primarily located in North America
-            consisting of fifty states. It shares land borders with Canada to its north
-            and with Mexico to its south and has maritime borders with the Bahamas, Cuba,
-            Russia, and other nations. With a population of over 333 million. The national
-            capital of the United States is Washington, D.C.
-            """),
-        schema=None,
-        value=_Country(
+        context='Brief intro to United States',
+        input=_Country(
             name='The United States of America',
             continents=['North America'],
             num_states=50,
@@ -154,5 +150,12 @@ DEFAULT_DESCRIBE_EXAMPLES: list[mapping.MappingExample] = [
             capital='Washington, D.C',
             president=None,
         ),
+        output=inspect.cleandoc("""
+            The United States of America is a country primarily located in North America
+            consisting of fifty states. It shares land borders with Canada to its north
+            and with Mexico to its south and has maritime borders with the Bahamas, Cuba,
+            Russia, and other nations. With a population of over 333 million. The national
+            capital of the United States is Washington, D.C.
+            """),
     ),
 ]