Release: ExceptionWrapper (#2451)

- release #2450 to avoid storing the locals in ExceptionWrapper.

Author: mikedh

pyproject.toml

@@ -5,7 +5,7 @@ requires = ["setuptools >= 61.0", "wheel"]
 [project]
 name = "trimesh"
 requires-python = ">=3.8"
-version = "4.8.0"
+version = "4.8.1"
 authors = [{name = "Michael Dawson-Haggerty", email = "mikedh@kerfed.com"}]
 license = {file = "LICENSE.md"}
 description = "Import, export, process, analyze and view triangular meshes."

tests/test_except.py

@@ -1,31 +1,40 @@
-try:
-    from . import generic as g
-except BaseException:
-    import generic as g
-
-
-class ExceptionsTest(g.unittest.TestCase):
-    def test_module(self):
-        # create an ExceptionWrapper
-        try:
-            raise ValueError("nah")
-        except BaseException as E:
-            em = g.trimesh.exceptions.ExceptionWrapper(E)
-
-        # checking isinstance should always return false
-        # and NOT raise the error
-        assert not isinstance(em, dict)
-
-        try:
-            # should re-raise `ValueError('nah')`
-            em.hi()
-            # if we're here raise an error we don't catch
-            raise NameError("should not have worked!!")
-        except ValueError:
-            # should have re-raised ValueError
-            pass
+def test_exception_wrapper():
+    # check our exception wrapping behavior
+    from trimesh.exceptions import ExceptionWrapper
+
+    try:
+        # create a wrapper around a ValueError
+        raise ValueError("This should be wrapped!")
+    except BaseException as E:
+        wrapper = ExceptionWrapper(E)
+
+    # `isinstance` should NOT raise the error that's been wrapped
+    assert not isinstance(wrapper, dict)
+
+    # but we should be able to tell that it is wrapping something
+    assert isinstance(wrapper, ExceptionWrapper)
+
+    try:
+        # check the __getattribute__ path
+        wrapper.hi()
+
+        # we wrapped something incorrectly if we got here!
+        raise NameError("__getattribute__ should have raised a ValueError!")
+    except ValueError:
+        # should have re-raised ValueError
+        pass
+
+    try:
+        # check the __call__ path
+        wrapper()
+
+        # we wrapped something incorrectly if we got here!
+        raise NameError("__call__ should have raised a ValueError!")
+
+    except ValueError:
+        # this is correct
+        pass
 
 
 if __name__ == "__main__":
-    g.trimesh.util.attach_to_log()
-    g.unittest.main()
+    test_exception_wrapper()

trimesh/exceptions.py

@@ -17,18 +17,24 @@ class ExceptionWrapper:
     actually requested so the user gets an easily debuggable message.
     """
 
-    def __init__(self, exception):
-        self.exception = exception
+    def __init__(self, exception: BaseException):
+        # store the exception type and the args rather than the whole thing
+        # this prevents the locals from the time of the exception
+        # from being stored as well.
+        self.exception = (type(exception), exception.args)
 
     def __getattribute__(self, *args, **kwargs):
         # will raise when this object is accessed like an object
         # if it's asking for our class type return None
         # this allows isinstance() checks to not re-raise
         if args[0] == "__class__":
             return None.__class__
-        # otherwise raise our original exception
-        raise super().__getattribute__("exception")
+
+        # re-create our original exception from the type and arguments
+        exc_type, exc_args = super().__getattribute__("exception")
+        raise exc_type(*exc_args)
 
     def __call__(self, *args, **kwargs):
-        # will raise when this object is called like a function
-        raise super().__getattribute__("exception")
+        # behave the same when this object is called like a function
+        # as when someone tries to access an attribute like a module
+        self.__getattribute__("exception")