pyglove 0.5.0.dev202508140811__tar.gz → 0.5.0.dev202511030811__tar.gz

{pyglove-0.5.0.dev202508140811 → pyglove-0.5.0.dev202511030811}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202508140811
+Version: 0.5.0.dev202511030811
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors

{pyglove-0.5.0.dev202508140811 → pyglove-0.5.0.dev202511030811}/pyglove/core/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2019 The PyGlove Authors
+# 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.
@@ -306,6 +306,7 @@ format = utils.format  # pylint: disable=redefined-builtin
 print = utils.print  # pylint: disable=redefined-builtin
 docstr = utils.docstr
 catch_errors = utils.catch_errors
+match_error = utils.match_error
 timeit = utils.timeit
 
 contextual_override = utils.contextual_override
@@ -352,6 +353,12 @@ from pyglove.core import coding
 
 from pyglove.core import logging
 
+#
+# Symbols from `monitoring.py`.
+#
+
+from pyglove.core import monitoring
+
 # pylint: enable=g-import-not-at-top
 # pylint: enable=reimported
 # pylint: enable=unused-import

{pyglove-0.5.0.dev202508140811 → pyglove-0.5.0.dev202511030811}/pyglove/core/geno/base.py

@@ -1447,6 +1447,7 @@ class DNA(symbolic.Object):
       *,
       allow_partial: bool = False,
       root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
   ) -> 'DNA':
     """Class method that load a DNA from a JSON value.
 
@@ -1454,6 +1455,7 @@ class DNA(symbolic.Object):
       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: Keyword arguments that will be passed to symbolic.from_json.
 
     Returns:
       A DNA object.
@@ -1463,16 +1465,18 @@ class DNA(symbolic.Object):
       # NOTE(daiyip): DNA.parse will validate the input. Therefore, we can
       # disable runtime type check during constructing the DNA objects.
       with symbolic.enable_type_check(False):
-        dna = DNA.parse(symbolic.from_json(json_value.get('value')))
+        dna = DNA.parse(symbolic.from_json(json_value.get('value'), **kwargs))
         if 'metadata' in json_value:
           dna.rebind(
-              metadata=symbolic.from_json(json_value.get('metadata')),
+              metadata=symbolic.from_json(json_value.get('metadata'), **kwargs),
               raise_on_no_change=False, skip_notification=True)
     else:
       dna = super(DNA, cls).from_json(
           json_value,
           allow_partial=allow_partial,
-          root_path=root_path)  # pytype: disable=bad-return-type
+          root_path=root_path,
+          **kwargs,
+      )  # pytype: disable=bad-return-type
       assert isinstance(dna, DNA)
     if cloneable_metadata_keys:
       dna._cloneable_metadata_keys = set(cloneable_metadata_keys)  # pylint: disable=protected-access

{pyglove-0.5.0.dev202508140811 → pyglove-0.5.0.dev202511030811}/pyglove/core/logging.py

@@ -17,9 +17,11 @@ This module allows PyGlove to use external created logger for logging PyGlove
 events without introducing library dependencies in PyGlove.
 """
 
+import contextlib
 import inspect
 import logging
-from typing import Any, Callable, List, Union
+import sys
+from typing import Any, Callable, Iterator, List, Union
 
 
 _DEFAULT_LOGGER = logging.getLogger()
@@ -117,3 +119,45 @@ def critical(msg: str, *args, **kwargs) -> None:
     **kwargs: Keyword arguments for the logger.
   """
   _DEFAULT_LOGGER.critical(msg, *args, **kwargs)
+
+
+def use_stream(
+    stream: Any,
+    level: int = logging.INFO,
+    name: str = 'custom',
+    fmt: str = '{levelname:8} | {asctime} | {message}',
+    datefmt: str = '%Y-%m-%d %H:%M:%S') -> logging.Logger:
+  """Use stdout for logging."""
+  logger = logging.getLogger(name)
+  logger.setLevel(level)
+  stdout_handler = logging.StreamHandler(stream=stream)
+  stdout_handler.setLevel(level)
+  stdout_handler.setFormatter(
+      logging.Formatter(fmt=fmt, datefmt=datefmt, style='{'))
+  logger.addHandler(stdout_handler)
+  set_logger(logger)
+  return logger
+
+
+def use_stdout(
+    level: int = logging.INFO,
+    fmt: str = '{levelname:8} | {asctime} | {message}',
+    datefmt: str = '%Y-%m-%d %H:%M:%S') -> logging.Logger:
+  """Use stdout for logging."""
+  return use_stream(sys.stdout, level, 'stdout', fmt, datefmt)
+
+
+@contextlib.contextmanager
+def redirect_stream(
+    stream: Any,
+    level: int = logging.INFO,
+    name: str = 'custom',
+    fmt: str = '{levelname:8} | {asctime} | {message}',
+    datefmt: str = '%Y-%m-%d %H:%M:%S') -> Iterator[logging.Logger]:
+  """Redirect the stream to the given logger."""
+  previous_logger = get_logger()
+  try:
+    logger = use_stream(stream, level, name, fmt, datefmt)
+    yield logger
+  finally:
+    set_logger(previous_logger)

{pyglove-0.5.0.dev202508140811 → pyglove-0.5.0.dev202511030811}/pyglove/core/logging_test.py

@@ -21,15 +21,9 @@ class LoggingTest(unittest.TestCase):
   """Tests for pg.logging."""
 
   def testLogging(self):
-    string_io = io.StringIO()
-    logger = logging.getLogger('logger1')
-    logger.setLevel(logging.INFO)
-    console_handler = logging.StreamHandler(stream=string_io)
-    console_handler.setLevel(logging.INFO)
-    logger.addHandler(console_handler)
-
     self.assertIs(pg_logging.get_logger(), logging.getLogger())
-    pg_logging.set_logger(logger)
+    string_io = io.StringIO()
+    logger = pg_logging.use_stream(string_io, name='logger1', fmt='')
     self.assertIs(pg_logging.get_logger(), logger)
 
     pg_logging.debug('x=%s', 1)
@@ -46,19 +40,16 @@ class LoggingTest(unittest.TestCase):
     ]) + '\n')
 
     string_io = io.StringIO()
-    logger = logging.getLogger('logger2')
-    logger.setLevel(logging.DEBUG)
-    console_handler = logging.StreamHandler(stream=string_io)
-    console_handler.setLevel(logging.DEBUG)
-    logger.addHandler(console_handler)
-
-    pg_logging.set_logger(logger)
-
-    pg_logging.debug('x=%s', 6)
-    self.assertEqual(string_io.getvalue(), '\n'.join([
-        'x=6',
-    ]) + '\n')
-
+    with pg_logging.redirect_stream(
+        string_io, level=logging.DEBUG, name='logger2', fmt=''
+    ):
+      pg_logging.debug('x=%s', 6)
+      self.assertEqual(string_io.getvalue(), '\n'.join([
+          'x=6',
+      ]) + '\n')
+
+    pg_logging.use_stdout()
+    pg_logging.info('y=%s', 7)
 
 if __name__ == '__main__':
   unittest.main()