pyglove 0.5.0.dev202508250811__py3-none-any.whl → 0.5.0.dev202511300809__py3-none-any.whl

pyglove/core/typing/value_specs.py

@@ -1930,8 +1930,12 @@ class Object(Generic, ValueSpecBase):
     elif isinstance(t, type):
       if t is object:
         raise TypeError('<class \'object\'> is too general for Object spec.')
+    elif getattr(t, '__no_type_check__', False):
+      t = object
     elif not pg_inspect.is_generic(t):
-      raise TypeError('"cls" for Object spec should be a type or str.')
+      raise TypeError(
+          f'"cls" for Object spec should be a type or str. Encountered: {t!r}.'
+      )
 
     self._forward_ref = forward_ref
     self._type_args = type_args

pyglove/core/typing/value_specs_test.py

@@ -2193,6 +2193,11 @@ class ObjectTest(ValueSpecTest):
     self.assertEqual(
         vs.Object(forward_ref('Foo')).forward_refs, set([forward_ref('Foo')]))
 
+  def test_no_type_check_special_handling(self):
+    x = self.A()
+    setattr(x, '__no_type_check__', True)
+    self.assertIs(vs.Object(x).cls, object)
+
   def test_default(self):
     self.assertEqual(vs.Object(self.A).default, typed_missing.MISSING_VALUE)
     a = self.A()

pyglove/core/utils/__init__.py

@@ -74,6 +74,7 @@ modules with the following features:
 from pyglove.core.utils.json_conversion import Nestable
 from pyglove.core.utils.json_conversion import JSONValueType
 
+from pyglove.core.utils.json_conversion import JSONConversionContext
 from pyglove.core.utils.json_conversion import JSONConvertible
 from pyglove.core.utils.json_conversion import from_json
 from pyglove.core.utils.json_conversion import to_json
@@ -148,6 +149,7 @@ from pyglove.core.utils.docstr_utils import docstr
 
 # Handling exceptions.
 from pyglove.core.utils.error_utils import catch_errors
+from pyglove.core.utils.error_utils import match_error
 from pyglove.core.utils.error_utils import CatchErrorsContext
 from pyglove.core.utils.error_utils import ErrorInfo
 

pyglove/core/utils/contextual.py

@@ -15,6 +15,7 @@
 
 import contextlib
 import dataclasses
+import inspect
 import threading
 from typing import Any, Callable, ContextManager, Iterator, Optional
 
@@ -89,10 +90,14 @@ def with_contextual_override(func: Callable[..., Any]) -> Callable[..., Any]:
   with contextual_override() as current_context:
     pass
 
-  def _func(*args, **kwargs) -> Any:
-    with contextual_override(**current_context):
-      return func(*args, **kwargs)
-
+  if inspect.iscoroutinefunction(func):
+    async def _func(*args, **kwargs) -> Any:
+      with contextual_override(**current_context):
+        return await func(*args, **kwargs)
+  else:
+    def _func(*args, **kwargs) -> Any:
+      with contextual_override(**current_context):
+        return func(*args, **kwargs)
   return _func
 
 

pyglove/core/utils/contextual_test.py

@@ -11,6 +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.
+import asyncio
 import concurrent.futures
 import unittest
 from pyglove.core.utils import contextual
@@ -83,6 +84,15 @@ class ContextualTest(unittest.TestCase):
           [3]
       )
 
+  def test_with_contextual_override_async_func(self):
+    async def func(i):
+      del i
+      return contextual.contextual_value('x')
+
+    with contextual.contextual_override(x=3):
+      self.assertEqual(
+          asyncio.run(contextual.with_contextual_override(func)(0)), 3
+      )
 
 if __name__ == '__main__':
   unittest.main()

pyglove/core/utils/error_utils.py

@@ -108,6 +108,64 @@ def catch_errors(
   Yields:
     A CatchErrorsContext object.
   """
+  errors = _parse_error_spec(errors)
+  context = CatchErrorsContext()
+  try:
+    yield context
+  except BaseException as e:    # pylint: disable=broad-exception-caught
+    if match_error(e, errors):
+      context.error = e
+      if error_handler is not None:
+        error_handler(e)
+    else:
+      raise
+
+
+def match_error(
+    error: BaseException,
+    errors: Union[
+        Union[Type[BaseException], Tuple[Type[BaseException], str]],
+        Sequence[Union[Type[BaseException], Tuple[Type[BaseException], str]]],
+        Dict[Type[BaseException], List[str]],
+    ],
+) -> bool:
+  """Returns True if the error matches the specification, .
+
+  Args:
+    error: The error to match.
+    errors: A sequence of exception types or tuples of exception type and error
+      messages (described in regular expression) as the desired exception types
+      to match.
+
+  Returns:
+    True if the error matches the specification, False otherwise.
+  """
+  error_mapping = _parse_error_spec(errors)
+  error_message = error.__class__.__name__ + ': ' + str(error)
+  for error_type, error_regexes in error_mapping.items():
+    if isinstance(error, error_type):
+      if not error_regexes:
+        return True
+      else:
+        for regex in error_regexes:
+          assert regex is not None
+          if not regex.startswith(('^', '.*')):
+            regex = '.*' + regex
+          if re.match(regex, error_message):
+            return True
+  return False
+
+
+def _parse_error_spec(
+    errors: Union[
+        Union[Type[BaseException], Tuple[Type[BaseException], str]],
+        Sequence[Union[Type[BaseException], Tuple[Type[BaseException], str]]],
+        Dict[Type[BaseException], List[str]],
+    ]
+) -> Dict[Type[BaseException], List[str]]:
+  """Parses a sequence of error specifications into a dictionary."""
+  if isinstance(errors, dict):
+    return errors
   if not isinstance(errors, (tuple, list)):
     errors = [errors]
   elif (
@@ -136,28 +194,4 @@ def catch_errors(
       error_mapping[error_type] = []
     if regex is not None:
       error_mapping[error_type].append(regex)
-
-  context = CatchErrorsContext()
-  try:
-    yield context
-  except tuple(error_mapping.keys()) as e:
-    error_message = e.__class__.__name__ + ': ' + str(e)
-    found_match = False
-    for error_type, error_regexes in error_mapping.items():
-      if isinstance(e, error_type):
-        if not error_regexes:
-          found_match = True
-        else:
-          for regex in error_regexes:
-            assert regex is not None
-            if not regex.startswith(('^', '.*')):
-              regex = '.*' + regex
-            if re.match(regex, error_message):
-              found_match = True
-              break
-    if found_match:
-      context.error = e
-      if error_handler is not None:
-        error_handler(e)
-    else:
-      raise e
+  return error_mapping