pyglove 0.4.5.dev202410290809__py3-none-any.whl → 0.4.5.dev202411010809__py3-none-any.whl

pyglove/core/object_utils/{profiling.py → timing.py}

@@ -11,12 +11,15 @@
 # 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.
-"""Utilities for profiling."""
+"""Utilities for timing."""
 
+import collections
 import dataclasses
 import time
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
+from pyglove.core.object_utils import error_utils
+from pyglove.core.object_utils import json_conversion
 from pyglove.core.object_utils import thread_local
 
 
@@ -24,12 +27,12 @@ class TimeIt:
   """Context manager for timing the execution of a code block."""
 
   @dataclasses.dataclass(frozen=True)
-  class Status:
+  class Status(json_conversion.JSONConvertible):
     """Status of a single `pg.timeit`."""
     name: str
-    elapse: float
-    has_ended: bool
-    error: Optional[Exception]
+    elapse: float = 0.0
+    has_ended: bool = True
+    error: Optional[error_utils.ErrorInfo] = None
 
     @property
     def has_started(self) -> bool:
@@ -41,18 +44,33 @@ class TimeIt:
       """Returns whether the context has error."""
       return self.error is not None
 
+    def to_json(self, **kwargs) -> Dict[str, Any]:
+      return self.to_json_dict(
+          fields=dict(
+              name=(self.name, None),
+              elapse=(self.elapse, 0.0),
+              has_ended=(self.has_ended, True),
+              error=(self.error, None),
+          ),
+          exclude_default=True,
+          **kwargs,
+      )
+
   @dataclasses.dataclass
-  class StatusSummary:
+  class StatusSummary(json_conversion.JSONConvertible):
     """Aggregated summary for repeated calls for `pg.timeit`."""
 
     @dataclasses.dataclass
-    class Entry:
+    class Entry(json_conversion.JSONConvertible):
       """Aggregated status from the `pg.timeit` calls of the same name."""
 
       num_started: int = 0
       num_ended: int = 0
       num_failed: int = 0
       avg_duration: float = 0.0
+      error_tags: Dict[str, int] = dataclasses.field(
+          default_factory=lambda: collections.defaultdict(int)
+      )
 
       def update(self, status: 'TimeIt.Status'):
         self.avg_duration = (
@@ -64,24 +82,52 @@ class TimeIt:
           self.num_ended += 1
         if status.has_error:
           self.num_failed += 1
+          assert status.error is not None
+          self.error_tags[status.error.tag] += 1
+
+      def to_json(self, **kwargs) -> Dict[str, Any]:
+        return self.to_json_dict(
+            fields=dict(
+                num_started=(self.num_started, 0),
+                num_ended=(self.num_ended, 0),
+                num_failed=(self.num_failed, 0),
+                avg_duration=(self.avg_duration, 0.0),
+                error_tags=(self.error_tags, {}),
+            ),
+            exclude_default=True,
+            **kwargs,
+        )
 
     breakdown: dict[str, 'TimeIt.StatusSummary.Entry'] = (
         dataclasses.field(default_factory=dict)
     )
 
-    def aggregate(self, timeit_obj: 'TimeIt'):
-      for k, v in timeit_obj.status().items():
+    def __bool__(self) -> bool:
+      """Returns True if the summary is non-empty."""
+      return bool(self.breakdown)
+
+    def aggregate(self, timeit_status: Dict[str, 'TimeIt.Status']):
+      for k, v in timeit_status.items():
         if k not in self.breakdown:
           self.breakdown[k] = TimeIt.StatusSummary.Entry()
         self.breakdown[k].update(v)
 
-  def __init__(self, name: str):
-    self._name = name
-    self._start_time = None
-    self._end_time = None
-    self._child_contexts = {}
-    self._error = None
-    self._parent = None
+    def to_json(self, **kwargs) -> Dict[str, Any]:
+      return self.to_json_dict(
+          fields=dict(
+              breakdown=(self.breakdown, {}),
+          ),
+          exclude_default=True,
+          **kwargs,
+      )
+
+  def __init__(self, name: str = ''):
+    self._name: str = name
+    self._start_time: Optional[float] = None
+    self._end_time: Optional[float] = None
+    self._child_contexts: Dict[str, TimeIt] = {}
+    self._error: Optional[error_utils.ErrorInfo] = None
+    self._parent: Optional[TimeIt] = None
 
   @property
   def name(self) -> str:
@@ -107,7 +153,9 @@ class TimeIt:
     """Ends timing."""
     if not self.has_ended:
       self._end_time = time.time()
-      self._error = error
+      self._error = (
+          None if error is None else error_utils.ErrorInfo.from_exception(error)
+      )
       return True
     return False
 
@@ -132,7 +180,7 @@ class TimeIt:
     return self._end_time
 
   @property
-  def error(self) -> Optional[BaseException]:
+  def error(self) -> Optional[error_utils.ErrorInfo]:
     """Returns error."""
     return self._error
 
@@ -161,7 +209,8 @@ class TimeIt:
     for child in self._child_contexts.values():
       child_result = child.status()
       for k, v in child_result.items():
-        result[f'{self.name}.{k}'] = v
+        key = f'{self.name}.{k}' if self.name else k
+        result[key] = v
     return result
 
   def __enter__(self):
@@ -182,6 +231,6 @@ class TimeIt:
       thread_local.thread_local_set('__timing_context__', self._parent)
 
 
-def timeit(name: str) -> TimeIt:
+def timeit(name: str = '') -> TimeIt:
   """Context manager to time a block of code."""
   return TimeIt(name)

pyglove/core/object_utils/{profiling_test.py → timing_test.py}

@@ -15,14 +15,15 @@
 import time
 import unittest
 
-from pyglove.core.object_utils import profiling
+from pyglove.core.object_utils import json_conversion
+from pyglove.core.object_utils import timing
 
 
 class TimeItTest(unittest.TestCase):
   """Tests for `pg.symbolic.thread_local`."""
 
   def test_basics(self):
-    tc = profiling.TimeIt('node')
+    tc = timing.TimeIt('node')
     self.assertFalse(tc.has_started)
     self.assertEqual(tc.elapse, 0)
 
@@ -37,7 +38,7 @@ class TimeItTest(unittest.TestCase):
     self.assertEqual(tc.elapse, elapse1)
 
   def test_timeit(self):
-    with profiling.timeit('node') as t:
+    with timing.timeit('node') as t:
       self.assertEqual(t.name, 'node')
       self.assertIsNotNone(t.start_time)
       self.assertTrue(t.has_started)
@@ -46,9 +47,9 @@ class TimeItTest(unittest.TestCase):
       time.sleep(0.5)
       elapse1 = t.elapse
       self.assertEqual(t.children, [])
-      with profiling.timeit('child') as t1:
+      with timing.timeit('child') as t1:
         time.sleep(0.5)
-        with profiling.timeit('grandchild') as t2:
+        with timing.timeit('grandchild') as t2:
           time.sleep(0.5)
 
         self.assertEqual(t.children, [t1])
@@ -63,7 +64,7 @@ class TimeItTest(unittest.TestCase):
         self.assertTrue(r['node.child.grandchild'].has_ended)
 
         with self.assertRaisesRegex(ValueError, '.* already exists'):
-          with profiling.timeit('grandchild'):
+          with timing.timeit('grandchild'):
             pass
 
     elapse2 = t.elapse
@@ -83,42 +84,49 @@ class TimeItTest(unittest.TestCase):
     )
     self.assertTrue(all(v.has_ended for v in statuss.values()))
     self.assertFalse(any(v.has_error for v in statuss.values()))
+    status = t.status()
+    json_dict = json_conversion.to_json(status)
+    status2 = json_conversion.from_json(json_dict)
+    self.assertIsNot(status2, status)
+    self.assertEqual(status2, status)
 
   def test_timeit_with_error(self):
     with self.assertRaises(ValueError):
-      with profiling.timeit('node') as t:
-        with profiling.timeit('child') as t1:
-          with profiling.timeit('grandchild') as t2:
+      with timing.timeit('node') as t:
+        with timing.timeit('child') as t1:
+          with timing.timeit('grandchild') as t2:
             raise ValueError('error')
 
     r = t.status()
     self.assertTrue(r['node'].has_error)
     self.assertTrue(t.has_error)
-    self.assertIsInstance(t.error, ValueError)
-    self.assertIsInstance(r['node'].error, ValueError)
+    self.assertTrue(t.error.tag.startswith('ValueError'))
+    self.assertTrue(r['node'].error.tag.startswith('ValueError'))
     self.assertTrue(r['node.child'].has_error)
     self.assertTrue(t1.has_error)
     self.assertTrue(r['node.child.grandchild'].has_error)
     self.assertTrue(t2.has_error)
 
   def test_timeit_summary(self):
-    summary = profiling.TimeIt.StatusSummary()
+    summary = timing.TimeIt.StatusSummary()
+    self.assertFalse(summary)
     for i in range(10):
-      with profiling.timeit('node') as t:
+      with timing.timeit() as t:
         time.sleep(0.1)
-        with profiling.timeit('child'):
+        with timing.timeit('child'):
           time.sleep(0.1)
           try:
-            with profiling.timeit('grandchild'):
+            with timing.timeit('grandchild'):
               time.sleep(0.1)
               if i < 2:
                 raise ValueError('error')
           except ValueError:
             pass
-      summary.aggregate(t)
+      summary.aggregate(t.status())
+    self.assertTrue(summary)
     self.assertEqual(
         list(summary.breakdown.keys()),
-        ['node', 'node.child', 'node.child.grandchild']
+        ['', 'child', 'child.grandchild']
     )
     self.assertEqual(
         [x.num_started for x in summary.breakdown.values()],
@@ -132,6 +140,15 @@ class TimeItTest(unittest.TestCase):
         [x.num_failed for x in summary.breakdown.values()],
         [0, 0, 2]
     )
+    self.assertEqual(
+        summary.breakdown['child.grandchild'].error_tags,
+        {'ValueError': 2},
+    )
+    # Test serialization.
+    json_dict = summary.to_json()
+    summary2 = timing.TimeIt.StatusSummary.from_json(json_dict)
+    self.assertIsNot(summary2, summary)
+    self.assertEqual(summary2.breakdown, summary.breakdown)
 
 
 if __name__ == '__main__':

pyglove/core/symbolic/__init__.py

@@ -120,6 +120,7 @@ from pyglove.core.symbolic.base import to_json
 from pyglove.core.symbolic.base import to_json_str
 from pyglove.core.symbolic.base import load
 from pyglove.core.symbolic.base import save
+from pyglove.core.symbolic.base import open_jsonl
 
 # Interfaces for pure symbolic objects.
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic

pyglove/core/symbolic/base.py

@@ -2041,13 +2041,16 @@ def contains(
   return not traverse(x, _contains)
 
 
-def from_json(json_value: Any,
-              *,
-              allow_partial: bool = False,
-              root_path: Optional[object_utils.KeyPath] = None,
-              auto_import: bool = True,
-              auto_dict: bool = False,
-              **kwargs) -> Any:
+def from_json(
+    json_value: Any,
+    *,
+    allow_partial: bool = False,
+    root_path: Optional[object_utils.KeyPath] = None,
+    auto_import: bool = True,
+    auto_dict: bool = False,
+    value_spec: Optional[pg_typing.ValueSpec] = None,
+    **kwargs
+) -> Any:
   """Deserializes a (maybe) symbolic value from JSON value.
 
   Example::
@@ -2073,6 +2076,7 @@ def from_json(json_value: Any,
       find the class 'A' within the imported module.
     auto_dict: If True, dict with '_type' that cannot be loaded will remain
       as dict, with '_type' renamed to 'type_name'.
+    value_spec: The value spec for the symbolic list or dict.
     **kwargs: Allow passing through keyword arguments to from_json of specific
       types.
 
@@ -2093,10 +2097,15 @@ def from_json(json_value: Any,
         json_value, auto_import=auto_import, auto_dict=auto_dict
     )
 
-  kwargs.update({
-      'allow_partial': allow_partial,
-      'root_path': root_path,
-  })
+  def _load_child(k, v):
+    return from_json(
+        v,
+        root_path=object_utils.KeyPath(k, root_path),
+        _typename_resolved=True,
+        allow_partial=allow_partial,
+        **kwargs
+    )
+
   if isinstance(json_value, list):
     if (json_value
         and json_value[0] == object_utils.JSONConvertible.TUPLE_MARKER):
@@ -2106,21 +2115,27 @@ def from_json(json_value: Any,
                 f'Tuple should have at least one element '
                 f'besides \'{object_utils.JSONConvertible.TUPLE_MARKER}\'. '
                 f'Encountered: {json_value}', root_path))
-      kwargs.pop('root_path')
-      return tuple([
-          from_json(
-              v,
-              root_path=object_utils.KeyPath(i, root_path),
-              _typename_resolved=True,
-              **kwargs
-          )
-          for i, v in enumerate(json_value[1:])
-      ])
-    return Symbolic.ListType(json_value, **kwargs)  # pytype: disable=not-callable   # pylint: disable=not-callable
+      return tuple(_load_child(i, v) for i, v in enumerate(json_value[1:]))
+    return Symbolic.ListType.from_json(    # pytype: disable=attribute-error
+        json_value,
+        value_spec=value_spec,
+        root_path=root_path,
+        allow_partial=allow_partial,
+        **kwargs,
+    )
   elif isinstance(json_value, dict):
     if object_utils.JSONConvertible.TYPE_NAME_KEY not in json_value:
-      return Symbolic.DictType.from_json(json_value, **kwargs)
-    return object_utils.from_json(json_value, _typename_resolved=True, **kwargs)
+      return Symbolic.DictType.from_json(   # pytype: disable=attribute-error
+          json_value,
+          value_spec=value_spec,
+          root_path=root_path,
+          allow_partial=allow_partial,
+          **kwargs,
+      )
+    return object_utils.from_json(
+        json_value, _typename_resolved=True,
+        root_path=root_path, allow_partial=allow_partial, **kwargs
+    )
   return json_value
 
 
@@ -2310,6 +2325,42 @@ def save(value: Any, path: str, *args, **kwargs) -> Any:
   return save_handler(value, path, *args, **kwargs)
 
 
+def open_jsonl(
+    path: str,
+    mode: str = 'r',
+    **kwargs
+) -> pg_io.Sequence:
+  """Open a JSONL file for reading or writing.
+
+  Example::
+
+    with pg.open_jsonl('my_file.jsonl', 'w') as f:
+      f.add(1)
+      f.add('foo')
+      f.add(dict(x=1))
+
+    with pg.open_jsonl('my_file.jsonl', 'r') as f:
+      for value in f:
+        print(value)
+
+  Args:
+    path: The path to the file.
+    mode: The mode of the file.
+    **kwargs: Additional keyword arguments that will be passed to
+      ``pg_io.open_sequence``.
+
+  Returns:
+    A sequence for PyGlove objects.
+  """
+  return pg_io.open_sequence(
+      path,
+      mode,
+      serializer=to_json_str,
+      deserializer=from_json_str,
+      **kwargs
+  )
+
+
 def default_load_handler(
     path: str,
     file_format: Literal['json', 'txt'] = 'json',

pyglove/core/symbolic/dict.py

@@ -152,10 +152,19 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         # Not okay:
         d.a.f2.abc = 1
     """
-    return cls(json_value,
-               value_spec=value_spec,
-               allow_partial=allow_partial,
-               root_path=root_path)
+    return cls(
+        {
+            k: base.from_json(
+                v,
+                root_path=object_utils.KeyPath(k, root_path),
+                allow_partial=allow_partial,
+                **kwargs
+            ) for k, v in json_value.items()
+        },
+        value_spec=value_spec,
+        root_path=root_path,
+        allow_partial=allow_partial,
+    )
 
   def __init__(self,
                dict_obj: Union[

pyglove/core/symbolic/list.py

@@ -132,10 +132,19 @@ class List(list, base.Symbolic, pg_typing.CustomTyping):
     Returns:
       A schema-less symbolic list, but its items maybe symbolic.
     """
-    return cls(json_value,
-               value_spec=value_spec,
-               allow_partial=allow_partial,
-               root_path=root_path)
+    return cls(
+        [
+            base.from_json(
+                v,
+                root_path=object_utils.KeyPath(i, root_path),
+                allow_partial=allow_partial,
+                **kwargs
+            ) for i, v in enumerate(json_value)
+        ],
+        value_spec=value_spec,
+        root_path=root_path,
+        allow_partial=allow_partial,
+    )
 
   def __init__(
       self,

pyglove/core/symbolic/object.py

@@ -543,7 +543,9 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
       json_value: Any,
       *,
       allow_partial: bool = False,
-      root_path: Optional[object_utils.KeyPath] = None) -> 'Object':
+      root_path: Optional[object_utils.KeyPath] = None,
+      **kwargs
+  ) -> 'Object':
     """Class method that load an symbolic Object from a JSON value.
 
     Example::
@@ -580,12 +582,13 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
       json_value: Input JSON value, only JSON dict is acceptable.
       allow_partial: Whether to allow elements of the list to be partial.
       root_path: KeyPath of loaded object in its object tree.
+      **kwargs: Additional keyword arguments to pass through.
 
     Returns:
       A symbolic Object instance.
     """
     return cls(allow_partial=allow_partial, root_path=root_path, **{
-        k: base.from_json(v, allow_partial=allow_partial)
+        k: base.from_json(v, allow_partial=allow_partial, **kwargs)
         for k, v in json_value.items()
     })
 

pyglove/core/views/html/base.py

@@ -333,7 +333,11 @@ class Html(base.Content):
     return s
 
   @classmethod
-  def escape(cls, s: WritableTypes) -> WritableTypes:
+  def escape(
+      cls,
+      s: WritableTypes,
+      javascript_str: bool = False
+  ) -> WritableTypes:
     """Escapes an HTML writable object."""
     if s is None:
       return None
@@ -341,11 +345,22 @@ class Html(base.Content):
     if callable(s):
       s = s()
 
-    if isinstance(s, str):
+    def _escape(s: str) -> str:
+      if javascript_str:
+        return (
+            s.replace('\\', '\\\\')
+            .replace('"', '\\"')
+            .replace('\r', '\\r')
+            .replace('\n', '\\n')
+            .replace('\t', '\\t')
+        )
       return html_lib.escape(s)
+
+    if isinstance(s, str):
+      return _escape(s)
     else:
       assert isinstance(s, Html), s
-      return Html(html_lib.escape(s.content)).write(
+      return Html(_escape(s.content)).write(
           s, shared_parts_only=True
       )
 

pyglove/core/views/html/base_test.py

@@ -695,6 +695,8 @@ class HtmlTest(TestCase):
     self.assertEqual(Html.escape('foo"bar'), 'foo"bar')
     self.assertEqual(Html.escape(Html('foo"bar')), Html('foo"bar'))
     self.assertEqual(Html.escape(lambda: 'foo"bar'), 'foo"bar')
+    self.assertEqual(Html.escape('"x=y"', javascript_str=True), '\\"x=y\\"')
+    self.assertEqual(Html.escape('x\n"', javascript_str=True), 'x\\n\\"')
 
   def test_concate(self):
     self.assertIsNone(Html.concate(None))

pyglove/core/views/html/tree_view.py

@@ -1215,6 +1215,7 @@ class HtmlTreeView(HtmlView):
       parent: Any = None,
       root_path: Optional[KeyPath] = None,
       css_classes: Optional[Sequence[str]] = None,
+      id: Optional[str] = None,  # pylint: disable=redefined-builtin
       content: Union[str, Html, None] = None,
       **kwargs,
   ) -> Html:
@@ -1225,8 +1226,9 @@ class HtmlTreeView(HtmlView):
       parent: The parent of the value.
       root_path: The root path of the value.
       css_classes: CSS classes to add to the HTML element.
+      id: The ID of the tooltip span element. If None, no ID will be added.
       content: The content to render. If None, the value will be rendered.
-      **kwargs: Additional keyword arguments passed from the user that 
+      **kwargs: Additional keyword arguments passed from the user that
         will be ignored.
 
     Returns:
@@ -1248,6 +1250,7 @@ class HtmlTreeView(HtmlView):
     return Html.element(
         'span',
         [content],
+        id=id,
         css_classes=[
             'tooltip',
             css_classes,
@@ -1266,6 +1269,9 @@ class HtmlTreeView(HtmlView):
           position: absolute;
           z-index: 1;
         }
+        span.tooltip:hover {
+          visibility: visible;
+        }
         """
     )
 

pyglove/core/views/html/tree_view_test.py

@@ -74,6 +74,9 @@ class TooltipTest(TestCase):
           position: absolute;
           z-index: 1;
         }
+        span.tooltip:hover {
+          visibility: visible;
+        }
         </style>
         """
     )
@@ -122,6 +125,9 @@ class SummaryTest(TestCase):
           position: absolute;
           z-index: 1;
         }
+        span.tooltip:hover {
+          visibility: visible;
+        }
         /* Summary styles. */
         details.pyglove summary {
           font-weight: bold;
@@ -314,6 +320,9 @@ class ContentTest(TestCase):
           position: absolute;
           z-index: 1;
         }
+        span.tooltip:hover {
+          visibility: visible;
+        }
         /* Summary styles. */
         details.pyglove summary {
           font-weight: bold;

{pyglove-0.4.5.dev202410290809.dist-info → pyglove-0.4.5.dev202411010809.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglove
-Version: 0.4.5.dev202410290809
+Version: 0.4.5.dev202411010809
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors