langfun 0.0.2.dev20240109__tar.gz → 0.0.2.dev20240111__tar.gz

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240109
+Version: 0.0.2.dev20240111
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,9 +21,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: google-generativeai>=0.3.2
 Requires-Dist: jinja2>=3.1.2
 Requires-Dist: openai==0.27.2
-Requires-Dist: pyglove>=0.4.5.dev20240105
+Requires-Dist: pyglove>=0.4.5.dev20240109
 Requires-Dist: requests>=2.31.0
 Requires-Dist: termcolor==1.1.0
 Requires-Dist: tqdm>=4.64.1

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/coding/python/execution.py

@@ -15,6 +15,7 @@
 
 import ast
 import contextlib
+import io
 import multiprocessing
 from typing import Any, Callable
 
@@ -24,6 +25,9 @@ from langfun.core.coding.python import permissions
 import pyglove as pg
 
 
+# Key in returned dict that captures stdout.
+STDOUT_KEY = '__stdout__'
+
 # Key in the returned dict that represents the final result.
 RESULT_KEY = '__result__'
 _TLS_CODE_RUN_CONTEXT = '__code_run_context__'
@@ -86,45 +90,51 @@ def evaluate(
   code, code_block = parsing.PythonCodeParser().parse(code, permission)
   global_vars, orig_global_vars = ctx, ctx.copy()
 
-  if hasattr(code_block.body[-1], 'value'):
-    last_expr = code_block.body.pop()  # pytype: disable=attribute-error
-    result_vars = [RESULT_KEY]
+  # No code.
+  if not code_block.body:
+    return {} if outputs_intermediate else None
 
-    if isinstance(last_expr, ast.Assign):
-      for name_node in last_expr.targets:
-        result_vars.append(name_node.id)
+  stdout = io.StringIO()
+  with contextlib.redirect_stdout(stdout):
+    if hasattr(code_block.body[-1], 'value'):
+      last_expr = code_block.body.pop()  # pytype: disable=attribute-error
+      result_vars = [RESULT_KEY]
 
-    last_expr = ast.Expression(last_expr.value)  # pytype: disable=attribute-error
+      if isinstance(last_expr, ast.Assign):
+        for name_node in last_expr.targets:
+          result_vars.append(name_node.id)
 
-    try:
-      # Execute the lines before the last expression.
-      # NOTE(daiyip): Only a `globals` dict is specified here, which will also
-      # be used to output intermediate values by `exec`. We do not specify a
-      # separate `locals` dict here, for - "If exec gets two separate objects as
-      # globals and locals, the code will be executed as if it were embedded in
-      # a class definition." - as the Python document explains. The outcome is
-      # that new functions defined in the code block could not be called by
-      # other newly defined functions.
-      # Refer to https://stackoverflow.com/questions/
-      # 73940751/why-cant-i-call-a-function-from-another-function-using-exec
-      # for more details.
-      exec(compile(code_block, '', mode='exec'), global_vars)  # pylint: disable=exec-used
-
-      # Evaluate the last expression.
-      result = eval(  # pylint: disable=eval-used
-          compile(last_expr, '', mode='eval'), global_vars
-      )
-    except Exception as e:
-      raise errors.CodeError(code, e) from e
+      last_expr = ast.Expression(last_expr.value)  # pytype: disable=attribute-error
 
-    for result_var in result_vars:
-      global_vars[result_var] = result
-  else:
-    try:
-      exec(compile(code_block, '', mode='exec'), global_vars)  # pylint: disable=exec-used
-    except Exception as e:
-      raise errors.CodeError(code, e) from e
-    global_vars[RESULT_KEY] = list(global_vars.values())[-1]
+      try:
+        # Execute the lines before the last expression.
+        # NOTE(daiyip): Only a `globals` dict is specified here, which will also
+        # be used to output intermediate values by `exec`. We do not specify a
+        # separate `locals` dict here, for - "If exec gets two separate objects
+        # as globals and locals, the code will be executed as if it were
+        # embedded in a class definition." - as the Python document explains.
+        # The outcome is that new functions defined in the code block could not
+        # be called by other newly defined functions.
+        # Refer to https://stackoverflow.com/questions/
+        # 73940751/why-cant-i-call-a-function-from-another-function-using-exec
+        # for more details.
+        exec(compile(code_block, '', mode='exec'), global_vars)  # pylint: disable=exec-used
+
+        # Evaluate the last expression.
+        result = eval(  # pylint: disable=eval-used
+            compile(last_expr, '', mode='eval'), global_vars
+        )
+      except Exception as e:
+        raise errors.CodeError(code, e) from e
+
+      for result_var in result_vars:
+        global_vars[result_var] = result
+    else:
+      try:
+        exec(compile(code_block, '', mode='exec'), global_vars)  # pylint: disable=exec-used
+      except Exception as e:
+        raise errors.CodeError(code, e) from e
+      global_vars[RESULT_KEY] = list(global_vars.values())[-1]
 
   if outputs_intermediate:
     outputs = {}
@@ -133,6 +143,8 @@ def evaluate(
         continue
       if k not in orig_global_vars or v is not orig_global_vars[k]:
         outputs[k] = v
+    # Add stdout to outputs.
+    outputs[STDOUT_KEY] = stdout.getvalue()
     return outputs
   return global_vars[RESULT_KEY]
 

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/coding/python/execution_test.py

@@ -36,7 +36,7 @@ class EvaluateTest(unittest.TestCase):
                 global_vars=dict(z=3),
                 outputs_intermediate=True,
             ),
-            dict(p=2 + 0 + 3, __result__=2 + 0 + 3),
+            dict(p=2 + 0 + 3, __result__=2 + 0 + 3, __stdout__=''),
         )
 
   def test_basics(self):
@@ -45,17 +45,19 @@ class EvaluateTest(unittest.TestCase):
             """
             x = 1
             y = x + 1
+            print(y)
             z = x + y
             """,
             outputs_intermediate=True,
         ),
-        dict(x=1, y=2, z=3, __result__=3),
+        dict(x=1, y=2, z=3, __result__=3, __stdout__='2\n'),
     )
     self.assertEqual(
         execution.evaluate(
             """
             x = 1
             y = x + 1
+            print(y)
             z = x + y
             """,
         ),
@@ -75,9 +77,10 @@ class EvaluateTest(unittest.TestCase):
         global_vars=dict(pg=pg),
         outputs_intermediate=True,
     )
-    self.assertEqual(list(ret.keys()), ['A', '__result__'])
+    self.assertEqual(list(ret.keys()), ['A', '__result__', '__stdout__'])
     self.assertTrue(issubclass(ret['A'], pg.Object))
     self.assertIs(ret['__result__'], ret['A'])
+    self.assertEqual(ret['__stdout__'], '')
 
   def test_function_def(self):
     ret = execution.evaluate(
@@ -91,7 +94,9 @@ class EvaluateTest(unittest.TestCase):
         permission=permissions.CodePermission.ALL,
         outputs_intermediate=True,
     )
-    self.assertEqual(list(ret.keys()), ['foo', 'bar', '__result__'])
+    self.assertEqual(
+        list(ret.keys()), ['foo', 'bar', '__result__', '__stdout__']
+    )
     self.assertTrue(inspect.isfunction(ret['foo']))
     self.assertTrue(inspect.isfunction(ret['bar']))
     self.assertIs(ret['__result__'], ret['bar'])
@@ -110,7 +115,9 @@ class EvaluateTest(unittest.TestCase):
         permission=permissions.CodePermission.ALL,
         outputs_intermediate=True,
     )
-    self.assertEqual(list(ret.keys()), ['foo', 'bar', '__result__'])
+    self.assertEqual(
+        list(ret.keys()), ['foo', 'bar', '__result__', '__stdout__']
+    )
     self.assertEqual(ret['__result__'], 3)
 
   def test_complex(self):
@@ -131,7 +138,9 @@ class EvaluateTest(unittest.TestCase):
         global_vars=dict(pg=pg),
         outputs_intermediate=True,
     )
-    self.assertEqual(list(ret.keys()), ['A', 'foo', 'k', '__result__'])
+    self.assertEqual(
+        list(ret.keys()), ['A', 'foo', 'k', '__result__', '__stdout__']
+    )
     self.assertTrue(issubclass(ret['A'], pg.Object))
     self.assertTrue(inspect.isfunction(ret['foo']))
     self.assertIsInstance(ret['k'], pg.Object)

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/coding/python/generation_test.py

@@ -41,9 +41,10 @@ class PythonCodeTest(unittest.TestCase):
         generation.PythonCode("""
             x = 1
             y = x + 1
+            print(y)
             z = x + y
             """).eval(),
-        dict(x=1, y=2, z=3, __result__=3),
+        dict(x=1, y=2, z=3, __result__=3, __stdout__='2\n'),
     )
 
   def test_call(self):

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/langfunc.py

@@ -326,18 +326,20 @@ class LangFunc(
     return lm_output
 
   @classmethod
-  def from_value(cls, value: Union[str, template_lib.Template]) -> 'LangFunc':
+  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)
+      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)
-    raise TypeError(f'Unsupported input type: {value!r}.')
+      return LangFunc(template_str=value, **kwargs)
+    return LangFunc('{{input}}', input=value, **kwargs)
 
 
 # Register converter from str to LangFunc, therefore we can always

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/langfunc_test.py

@@ -64,8 +64,8 @@ class BasicTest(unittest.TestCase):
     l3 = LangFunc.from_value(c.l)
     self.assertEqual(l3.render(), '1 + 2')
 
-    with self.assertRaisesRegex(TypeError, 'Unsupported input type'):
-      LangFunc.from_value(1)
+    l4 = LangFunc.from_value(1)
+    self.assertEqual(l4.render(), '1')
 
 
 class LangFuncCallTest(unittest.TestCase):

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/llms/__init__.py

@@ -23,6 +23,11 @@ from langfun.core.llms.fake import StaticMapping
 from langfun.core.llms.fake import StaticResponse
 from langfun.core.llms.fake import StaticSequence
 
+# Gemini models.
+from langfun.core.llms.gemini import Gemini
+from langfun.core.llms.gemini import GeminiPro
+from langfun.core.llms.gemini import GeminiProVision
+
 # OpenAI models.
 from langfun.core.llms.openai import OpenAI
 

langfun-0.0.2.dev20240111/langfun/core/llms/gemini.py

@@ -0,0 +1,190 @@
+# 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.
+"""Gemini models exposed through Google Generative AI APIs."""
+
+import functools
+import os
+from typing import Annotated, Any, Literal
+
+import google.generativeai as genai
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+
+
+@lf.use_init_args(['model'])
+class Gemini(lf.LanguageModel):
+  """Language model served on VertexAI."""
+
+  model: Annotated[
+      Literal['gemini-pro', 'gemini-pro-vision', ''],
+      'Model name.',
+  ]
+
+  api_key: Annotated[
+      str | None,
+      (
+          'API key. If None, the key will be read from environment variable '
+          "'GOOGLE_API_KEY'."
+      ),
+  ] = 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):
+    api_key = self.api_key or os.environ.get('GOOGLE_API_KEY', None)
+    if not api_key:
+      raise ValueError(
+          'Please specify `api_key` during `__init__` or set environment '
+          'variable `GOOGLE_API_KEY` with your Google Cloud API key. '
+          'Check out '
+          'https://cloud.google.com/api-keys/docs/create-manage-api-keys '
+          'for more details.'
+      )
+    genai.configure(api_key=api_key)
+    return True
+
+  @classmethod
+  def dir(cls) -> list[str]:
+    """Lists generative models."""
+    return [
+        m.name.lstrip('models/')
+        for m in genai.list_models()
+        if 'generateContent' in m.supported_generation_methods
+    ]
+
+  @property
+  def model_id(self) -> str:
+    """Returns a string to identify the model."""
+    return 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:
+    """Max concurrent requests."""
+    return 8
+
+  def _generation_config(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+    """Creates generation config from langfun sampling options."""
+    return genai.GenerationConfig(
+        candidate_count=options.n,
+        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 | genai.types.BlobDict]:
+    """Gets Evergreen formatted content from langfun message."""
+    formatted = lf.UserMessage(prompt.text)
+    formatted.source = prompt
+
+    chunks = []
+    for lf_chunk in formatted.chunk():
+      if isinstance(lf_chunk, str):
+        chunk = lf_chunk
+      elif self.multimodal and isinstance(lf_chunk, lf_modalities.Image):
+        chunk = genai.types.BlobDict(
+            data=lf_chunk.to_bytes(), mime_type=f'image/{lf_chunk.image_format}'
+        )
+      else:
+        raise ValueError(f'Unsupported modality: {lf_chunk!r}')
+      chunks.append(chunk)
+    return chunks
+
+  def _response_to_result(
+      self, response: genai.types.GenerateContentResponse
+  ) -> lf.LMSamplingResult:
+    """Parses generative response into message."""
+    samples = []
+    for candidate in response.candidates:
+      chunks = []
+      for part in candidate.content.parts:
+        # TODO(daiyip): support multi-modal parts when they are available via
+        # Gemini API.
+        if hasattr(part, 'text'):
+          chunks.append(part.text)
+      samples.append(lf.LMSample(lf.AIMessage.from_chunks(chunks), score=0.0))
+    return lf.LMSamplingResult(samples)
+
+  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:
+    """Samples a single prompt."""
+    model = _GOOGLE_GENAI_MODEL_HUB.get(self.model)
+    input_content = self._content_from_message(prompt)
+    response = model.generate_content(
+        input_content,
+        generation_config=self._generation_config(self.sampling_options),
+    )
+    return self._response_to_result(response)
+
+
+class _ModelHub:
+  """Google Generative AI model hub."""
+
+  def __init__(self):
+    self._model_cache = {}
+
+  def get(self, model_name: str) -> genai.GenerativeModel:
+    """Gets a generative model by model id."""
+    model = self._model_cache.get(model_name, None)
+    if model is None:
+      model = genai.GenerativeModel(model_name)
+      self._model_cache[model_name] = model
+    return model
+
+
+_GOOGLE_GENAI_MODEL_HUB = _ModelHub()
+
+
+#
+# Public Gemini models.
+#
+
+
+class GeminiPro(Gemini):
+  """Gemini Pro model."""
+
+  model = 'gemini-pro'
+
+
+class GeminiProVision(Gemini):
+  """Gemini Pro vision model."""
+
+  model = 'gemini-pro-vision'
+  multimodal = True

langfun-0.0.2.dev20240111/langfun/core/llms/gemini_test.py

@@ -0,0 +1,163 @@
+# 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 import generativeai as genai
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+from langfun.core.llms import gemini
+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 = generation_config
+  return genai.types.GenerateContentResponse(
+      done=True,
+      iterator=None,
+      chunks=[],
+      result=pg.Dict(
+          prompt_feedback=pg.Dict(block_reason=None),
+          candidates=[
+              pg.Dict(
+                  content=pg.Dict(
+                      parts=[
+                          pg.Dict(
+                              text=(
+                                  f'This is a response to {content[0]} with '
+                                  f'n={c.candidate_count}, '
+                                  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={c.stop_sequences}.'
+                              )
+                          )
+                      ]
+                  ),
+              ),
+          ],
+      ),
+  )
+
+
+class GeminiTest(unittest.TestCase):
+  """Tests for Evergreen language model."""
+
+  def test_content_from_message_text_only(self):
+    text = 'This is a beautiful day'
+    model = gemini.GeminiPro()
+    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'):
+      gemini.GeminiPro()._content_from_message(message)
+
+    model = gemini.GeminiProVision()
+    chunks = model._content_from_message(message)
+    self.maxDiff = None
+    self.assertEqual(
+        chunks,
+        [
+            'This is an',
+            genai.types.BlobDict(mime_type='image/png', data=example_image),
+            ', what is it?',
+        ],
+    )
+
+  def test_response_to_result_text_only(self):
+    response = genai.types.GenerateContentResponse(
+        done=True,
+        iterator=None,
+        chunks=[],
+        result=pg.Dict(
+            prompt_feedback=pg.Dict(block_reason=None),
+            candidates=[
+                pg.Dict(
+                    content=pg.Dict(
+                        parts=[pg.Dict(text='This is response 1.')]
+                    ),
+                ),
+                pg.Dict(
+                    content=pg.Dict(parts=[pg.Dict(text='This is response 2.')])
+                ),
+            ],
+        ),
+    )
+    model = gemini.GeminiProVision()
+    result = model._response_to_result(response)
+    self.assertEqual(
+        result,
+        lf.LMSamplingResult([
+            lf.LMSample(lf.AIMessage('This is response 1.'), score=0.0),
+            lf.LMSample(lf.AIMessage('This is response 2.'), score=0.0),
+        ]),
+    )
+
+  def test_model_hub(self):
+    model = gemini._GOOGLE_GENAI_MODEL_HUB.get('gemini-pro')
+    self.assertIsNotNone(model)
+    self.assertIs(gemini._GOOGLE_GENAI_MODEL_HUB.get('gemini-pro'), model)
+
+  def test_api_key_check(self):
+    with self.assertRaisesRegex(ValueError, 'Please specify `api_key`'):
+      _ = gemini.GeminiPro()._api_initialized
+
+    self.assertTrue(gemini.GeminiPro(api_key='abc')._api_initialized)
+    os.environ['GOOGLE_API_KEY'] = 'abc'
+    self.assertTrue(gemini.GeminiPro()._api_initialized)
+    del os.environ['GOOGLE_API_KEY']
+
+  def test_call(self):
+    with mock.patch(
+        'google.generativeai.generative_models.GenerativeModel.generate_content'
+    ) as mock_generate:
+      mock_generate.side_effect = mock_generate_content
+
+      lm = gemini.GeminiPro(api_key='test_key')
+      self.maxDiff = None
+      self.assertEqual(
+          lm('hello', temperature=2.0, top_k=20).text,
+          (
+              'This is a response to hello with n=1, temperature=2.0, '
+              'top_p=None, top_k=20, max_tokens=1024, stop=None.'
+          ),
+      )
+
+
+if __name__ == '__main__':
+  unittest.main()

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/message.py

@@ -195,7 +195,7 @@ class Message(natural_language.NaturalLanguageFormattable, pg.Object):
     if key_path == Message.PATH_TEXT:
       return self.text
     else:
-      v = self.metadata.sym_get(key_path, default)
+      v = self.metadata.sym_get(key_path, default, use_inferred=True)
       return v.value if isinstance(v, pg.Ref) else v
 
   #

{langfun-0.0.2.dev20240109 → langfun-0.0.2.dev20240111}/langfun/core/message_test.py

@@ -110,16 +110,17 @@ class MessageTest(unittest.TestCase):
   def test_get(self):
 
     class A(pg.Object):
-      pass
+      p: int
 
     # Create a symbolic object and assign it to a container, so we could test
     # pg.Ref.
-    a = A()
+    a = A(1)
     d = pg.Dict(x=a)
 
     m = message.UserMessage('hi', x=pg.Ref(a), y=dict(z=[0, 1, 2]))
     self.assertEqual(m.get('text'), 'hi')
     self.assertIs(m.get('x'), a)
+    self.assertIs(m.get('x.p'), 1)
     self.assertEqual(m.get('y'), dict(z=[0, 1, 2]))
     self.assertEqual(m.get('y.z'), [0, 1, 2])
     self.assertEqual(m.get('y.z[0]'), 0)