pyglove 0.4.5.dev20240319__tar.gz → 0.4.5.dev202501140808__tar.gz

{pyglove-0.4.5.dev20240319 → pyglove-0.4.5.dev202501140808}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyglove
-Version: 0.4.5.dev20240319
+Version: 0.4.5.dev202501140808
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors
@@ -22,6 +22,17 @@ Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: docstring-parser>=0.12
+Requires-Dist: termcolor>=1.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 <div align="center">
 <img src="https://raw.githubusercontent.com/google/pyglove/main/docs/_static/logo_light.svg#gh-light-mode-only" width="320px" alt="logo"></img>
@@ -72,7 +83,7 @@ It's commonly used in:
 PyGlove has been [published](https://proceedings.neurips.cc/paper/2020/file/012a91467f210472fab4e11359bbfef6-Paper.pdf)
 at NeurIPS 2020. It is widely used within [Alphabet](https://abc.xyz/), including Google Research, Google Cloud, Youtube and Waymo.
 
-PyGlove is developed by Daiyi Peng and colleagues in [Google Brain Team](https://research.google/teams/brain/).
+PyGlove is developed by Daiyi Peng and colleagues at [Google Brain](https://research.google/teams/brain/).
 
 
 ## Hello PyGlove
@@ -145,6 +156,9 @@ pip install pyglove --pre
   * [Interactive SVG: Components for Direct Manipulation](https://github.com/google/pyglove/blob/main/docs/notebooks/python/interactive_svg.ipynb)
   * [Where is the Duck: Developing Context-aware Component](https://github.com/google/pyglove/blob/main/docs/notebooks/python/where_is_the_duck.ipynb)
 
+* Interactive Programming
+  * [Viewing PyGlove objects in HTML](https://colab.research.google.com/github/google/pyglove/blob/main/docs/notebooks/gui/html_view.ipynb)
+
 ## Citing PyGlove
 
 ```

{pyglove-0.4.5.dev20240319 → pyglove-0.4.5.dev202501140808}/README.md

@@ -47,7 +47,7 @@ It's commonly used in:
 PyGlove has been [published](https://proceedings.neurips.cc/paper/2020/file/012a91467f210472fab4e11359bbfef6-Paper.pdf)
 at NeurIPS 2020. It is widely used within [Alphabet](https://abc.xyz/), including Google Research, Google Cloud, Youtube and Waymo.
 
-PyGlove is developed by Daiyi Peng and colleagues in [Google Brain Team](https://research.google/teams/brain/).
+PyGlove is developed by Daiyi Peng and colleagues at [Google Brain](https://research.google/teams/brain/).
 
 
 ## Hello PyGlove
@@ -120,6 +120,9 @@ pip install pyglove --pre
   * [Interactive SVG: Components for Direct Manipulation](https://github.com/google/pyglove/blob/main/docs/notebooks/python/interactive_svg.ipynb)
   * [Where is the Duck: Developing Context-aware Component](https://github.com/google/pyglove/blob/main/docs/notebooks/python/where_is_the_duck.ipynb)
 
+* Interactive Programming
+  * [Viewing PyGlove objects in HTML](https://colab.research.google.com/github/google/pyglove/blob/main/docs/notebooks/gui/html_view.ipynb)
+
 ## Citing PyGlove
 
 ```

{pyglove-0.4.5.dev20240319 → pyglove-0.4.5.dev202501140808}/pyglove/core/__init__.py

@@ -37,8 +37,7 @@ Here lists the sub-modules included in the core PyGlove library:
    |__ tuning          :  Interface for program tuning with a local backend.
    |__ detouring       :  Detouring classes creation without symbolic types.
    |__ patching        :  Patching a program with URL-like strings.
-   |__ object_utils    :  Utility libary on operating with Python objects.
-
+   |__ utils           :  Utility libary on operating with Python objects.
 """
 
 # NOTE(daiyip): We disable bad-import-order to preserve the relation of
@@ -163,6 +162,7 @@ to_json = symbolic.to_json
 to_json_str = symbolic.to_json_str
 save = symbolic.save
 load = symbolic.load
+open_jsonl = symbolic.open_jsonl
 get_load_handler = symbolic.get_load_handler
 set_load_handler = symbolic.set_load_handler
 get_save_handler = symbolic.get_save_handler
@@ -192,7 +192,8 @@ CustomTyping = typing.CustomTyping
 
 get_converter = typing.get_converter
 register_converter = typing.register_converter
-get_signature = typing.get_signature
+signature = typing.signature
+schema = typing.schema
 
 
 #
@@ -271,29 +272,56 @@ ObjectFactory = patching.ObjectFactory
 
 
 #
-# Symbols from 'object_utils' sub-module.
+# Symbols from 'utils' sub-module.
 #
 
-from pyglove.core import object_utils
-KeyPath = object_utils.KeyPath
-MISSING_VALUE = object_utils.MISSING_VALUE
+from pyglove.core import utils
+
+# For backward compatibility.
+object_utils = utils
+
+KeyPath = utils.KeyPath
+KeyPathSet = utils.KeyPathSet
+MISSING_VALUE = utils.MISSING_VALUE
+
+Formattable = utils.Formattable
+repr_format = utils.repr_format
+str_format = utils.str_format
+
+MaybePartial = utils.MaybePartial
+JSONConvertible = utils.JSONConvertible
+DocStr = utils.DocStr
+
+registered_types = utils.registered_types
+explicit_method_override = utils.explicit_method_override
 
-Formattable = object_utils.Formattable
-repr_format = object_utils.repr_format
-str_format = object_utils.str_format
+is_partial = utils.is_partial
+format = utils.format  # pylint: disable=redefined-builtin
+print = utils.print  # pylint: disable=redefined-builtin
+docstr = utils.docstr
+catch_errors = utils.catch_errors
+timeit = utils.timeit
 
-MaybePartial = object_utils.MaybePartial
-JSONConvertible = object_utils.JSONConvertible
-DocStr = object_utils.DocStr
+colored = utils.colored
+decolor = utils.decolor
 
-registered_types = object_utils.registered_types
-explicit_method_override = object_utils.explicit_method_override
+# Symbols from 'views' sub-module.
+
+from pyglove.core import views
+view = views.view
+view_options = views.view_options
+View = views.View
+Html = views.Html
+to_html = views.to_html
+to_html_str = views.to_html_str
+
+# NOTE(daiyip): Hack to add `controls` to `pg.views.html`.
+# We exclude `html.controls` from `pyglove.core.views.html` package to avoid
+# circular dependency between `pyglove.core.views.html` and
+# `pyglove.core.symbolic`.
+from pyglove.core.views.html import controls
+views.html.controls = controls
 
-is_partial = object_utils.is_partial
-format = object_utils.format   # pylint: disable=redefined-builtin
-print = object_utils.print    # pylint: disable=redefined-builtin
-docstr = object_utils.docstr
-catch_errors = object_utils.catch_errors
 
 #
 # Symbols from `io` sub-module.
@@ -301,6 +329,12 @@ catch_errors = object_utils.catch_errors
 
 from pyglove.core import io
 
+#
+# Symbols from `coding` sub-module.
+#
+#
+
+from pyglove.core import coding
 
 #
 # Symbols from `logging.py`.

pyglove-0.4.5.dev202501140808/pyglove/core/coding/__init__.py

@@ -0,0 +1,42 @@
+# Copyright 2024 The PyGlove 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.
+# pylint: disable=line-too-long
+"""Code generation utilities."""
+
+# pylint: enable=line-too-long
+# pylint: disable=g-bad-import-order
+# pylint: disable=g-importing-member
+
+from pyglove.core.coding.errors import CodeError
+from pyglove.core.coding.errors import SerializationError
+
+from pyglove.core.coding.permissions import CodePermission
+from pyglove.core.coding.permissions import permission
+from pyglove.core.coding.permissions import get_permission
+
+from pyglove.core.coding.parsing import parse
+
+from pyglove.core.coding.execution import context
+from pyglove.core.coding.execution import get_context
+from pyglove.core.coding.execution import evaluate
+from pyglove.core.coding.execution import sandbox_call
+from pyglove.core.coding.execution import maybe_sandbox_call
+from pyglove.core.coding.execution import run
+
+from pyglove.core.coding.function_generation import NO_TYPE_ANNOTATION
+from pyglove.core.coding.function_generation import make_function
+
+# pylint: disable=line-too-long
+# pylint: enable=g-bad-import-order
+# pylint: enable=g-importing-member

pyglove-0.4.5.dev202501140808/pyglove/core/coding/errors.py

@@ -0,0 +1,111 @@
+# Copyright 2025 The PyGlove 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.
+"""Python code errors."""
+
+import io
+import sys
+import textwrap
+import traceback
+from typing import Optional
+
+from pyglove.core import utils
+
+
+class CodeError(RuntimeError):
+  """Python code error."""
+
+  def __init__(
+      self,
+      code: str,
+      cause: Exception,
+      ):
+    self.code = code
+    self.cause = cause
+
+    # Figure out the starting and ending line numbers of the erratic code.
+    lineno = None
+    end_lineno = None
+    if isinstance(cause, SyntaxError):
+      lineno = cause.lineno
+      # For Python 3.9 and below, `end_lineno` is not available.
+      end_lineno = getattr(cause, 'end_lineno', lineno)
+    elif not isinstance(cause, TimeoutError):
+      tb = sys.exc_info()[2]
+      frames = traceback.extract_tb(tb, limit=5)
+      for f in frames:
+        if not f.filename or f.filename == '<string>':
+          lineno = f.lineno
+          end_lineno = lineno
+          break
+    self.lineno = lineno
+    self.end_lineno = end_lineno
+
+  def __str__(self):
+    return self.format(include_complete_code=True)
+
+  def code_lines(self, start_line: int, end_line: int):
+    """Returns code lines ."""
+    return '\n'.join(self.code.split('\n')[start_line:end_line])
+
+  def format(self, include_complete_code: bool = True):
+    """Formats the code error."""
+    r = io.StringIO()
+    error_message = str(self.cause).rstrip()
+    if 'line' not in error_message and self.lineno is not None:
+      error_message += f' (<unknown>, line {self.lineno})'
+    r.write(
+        utils.colored(
+            f'{self.cause.__class__.__name__}: {error_message}', 'magenta'))
+
+    if self.lineno is not None:
+      r.write('\n\n')
+      r.write(textwrap.indent(
+          utils.colored(
+              self.code_lines(self.lineno - 1, self.end_lineno), 'magenta'),
+          ' ' * 2
+      ))
+      r.write('\n')
+
+    if include_complete_code:
+      r.write('\n')
+      r.write(utils.colored('[Code]', 'green', styles=['bold']))
+      r.write('\n\n')
+      r.write(utils.colored('  ```python\n', 'green'))
+      r.write(textwrap.indent(
+          utils.colored(self.code, 'green'),
+          ' ' * 2
+      ))
+      r.write(utils.colored('\n  ```\n', 'green'))
+    return r.getvalue()
+
+
+class SerializationError(RuntimeError):
+  """Object serialization error."""
+
+  def __init__(self, message: Optional[str], cause: Exception):
+    self.message = message
+    self.cause = cause
+
+  def __str__(self):
+    r = io.StringIO()
+    cause_message = str(self.cause).rstrip()
+    if self.message:
+      r.write(utils.colored(self.message, 'magenta'))
+      r.write('\n\n')
+    r.write(
+        utils.colored(
+            f'{self.cause.__class__.__name__}: {cause_message}', 'magenta'
+        )
+    )
+    return r.getvalue()

pyglove-0.4.5.dev202501140808/pyglove/core/coding/errors_test.py

@@ -0,0 +1,98 @@
+# Copyright 2025 The PyGlove 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.
+import inspect
+import unittest
+
+from pyglove.core.coding import errors
+from pyglove.core.coding import execution
+
+
+def code_error(code: str) -> errors.CodeError:
+  try:
+    execution.run(inspect.cleandoc(code), timeout=2)
+    assert False, 'should not reach here'
+  except errors.CodeError as e:
+    return e
+
+
+class CodeErrorsTest(unittest.TestCase):
+
+  def test_format(self):
+    e = code_error(
+        """
+        x = y + 1
+        """
+    )
+    self.assertIn('[Code]', str(e))
+    self.assertNotIn(
+        '[Code]', e.format(include_complete_code=False))
+
+  def test_lineno(self):
+    self.assertEqual(
+        code_error(
+            """
+            x = y + 1
+            """
+        ).lineno, 1)
+    self.assertEqual(
+        code_error(
+            """
+            x = 1
+            for i of x:
+              y = i
+            """
+        ).lineno, 2)
+    self.assertEqual(
+        code_error(
+            """
+            x = 1
+            y = 2
+            raise ValueError
+            """
+        ).lineno, 3)
+
+  def test_lineno_in_error_message(self):
+    def assert_lineno(code):
+      e = code_error(code)
+      self.assertIn('line', e.format(include_complete_code=False))
+
+    assert_lineno(
+        """
+        x = y + 1
+        """
+    )
+    assert_lineno(
+        """
+        x = 1
+          y = 2
+        """
+    )
+    assert_lineno(
+        """
+        raise ValueError()
+        """
+    )
+
+
+class SerializationErrorTest(unittest.TestCase):
+
+  def test_str(self):
+    e = errors.SerializationError(
+        'Output cannot be serialized.', ValueError('abc'))
+    self.assertIn('Output cannot be serialized', str(e))
+    self.assertIn('ValueError: abc', str(e))
+
+
+if __name__ == '__main__':
+  unittest.main()