ob-metaflow 2.11.4.9__py2.py3-none-any.whl → 2.11.9.1__py2.py3-none-any.whl

metaflow/plugins/env_escape/consts.py

@@ -39,6 +39,7 @@ OP_GETVAL = 15
 OP_SETVAL = 16
 OP_INIT = 17
 OP_CALLONCLASS = 18
+OP_SUBCLASSCHECK = 19
 
 # Control messages
 CONTROL_SHUTDOWN = 1

metaflow/plugins/env_escape/exception_transferer.py

@@ -4,11 +4,9 @@ import traceback
 try:
     # Import from client
     from .data_transferer import DataTransferer
-    from .stub import Stub
 except ImportError:
     # Import from server
     from data_transferer import DataTransferer
-    from stub import Stub
 
 
 # This file is heavily inspired from the RPYC project
@@ -39,7 +37,6 @@ except ImportError:
 FIELD_EXC_MODULE = "m"
 FIELD_EXC_NAME = "n"
 FIELD_EXC_ARGS = "arg"
-FIELD_EXC_ATTR = "atr"
 FIELD_EXC_TB = "tb"
 FIELD_EXC_USER = "u"
 FIELD_EXC_SI = "si"
@@ -54,7 +51,6 @@ def dump_exception(data_transferer, exception_type, exception_val, tb, user_data
         traceback.format_exception(exception_type, exception_val, tb)
     )
     exception_args = []
-    exception_attrs = []
     str_repr = None
     repr_repr = None
     for name in dir(exception_val):
@@ -72,20 +68,10 @@ def dump_exception(data_transferer, exception_type, exception_val, tb, user_data
             repr_repr = repr(exception_val)
         elif name.startswith("_") or name == "with_traceback":
             continue
-        else:
-            try:
-                attr = getattr(exception_val, name)
-            except AttributeError:
-                continue
-            if DataTransferer.can_simple_dump(attr):
-                exception_attrs.append((name, attr))
-            else:
-                exception_attrs.append((name, repr(attr)))
     to_return = {
         FIELD_EXC_MODULE: exception_type.__module__,
         FIELD_EXC_NAME: exception_type.__name__,
         FIELD_EXC_ARGS: exception_args,
-        FIELD_EXC_ATTR: exception_attrs,
         FIELD_EXC_TB: local_formatted_exception,
         FIELD_EXC_STR: str_repr,
         FIELD_EXC_REPR: repr_repr,
@@ -98,121 +84,69 @@ def dump_exception(data_transferer, exception_type, exception_val, tb, user_data
     return data_transferer.dump(to_return)
 
 
-def load_exception(data_transferer, json_obj):
-    json_obj = data_transferer.load(json_obj)
+def load_exception(client, json_obj):
+    from .stub import Stub
+
+    json_obj = client.decode(json_obj)
+
     if json_obj.get(FIELD_EXC_SI) is not None:
         return StopIteration
 
     exception_module = json_obj.get(FIELD_EXC_MODULE)
     exception_name = json_obj.get(FIELD_EXC_NAME)
     exception_class = None
-    if exception_module not in sys.modules:
-        # Try to import the module
-        try:
-            # Use __import__ so that the user can access this exception
-            __import__(exception_module, None, None, "*")
-        except Exception:
-            pass
-    # Try again (will succeed if the __import__ worked)
-    if exception_module in sys.modules:
-        exception_class = getattr(sys.modules[exception_module], exception_name, None)
-    if exception_class is None or issubclass(exception_class, Stub):
-        # Best effort to "recreate" an exception. Note that in some cases, exceptions
-        # may actually be both exceptions we can transfer as well as classes we
-        # can transfer (stubs) but for exceptions, we don't want to use the stub
-        # otherwise it will just ping pong.
-        name = "%s.%s" % (exception_module, exception_name)
-        exception_class = _remote_exceptions_class.setdefault(
-            name,
-            type(
-                name,
-                (RemoteInterpreterException,),
-                {"__module__": "%s/%s" % (__name__, exception_module)},
-            ),
-        )
-    exception_class = _wrap_exception(exception_class)
-    raised_exception = exception_class.__new__(exception_class)
-    raised_exception.args = json_obj.get(FIELD_EXC_ARGS)
-    for name, attr in json_obj.get(FIELD_EXC_ATTR):
-        try:
-            if name in raised_exception.__user_defined__:
-                setattr(raised_exception, "_original_%s" % name, attr)
-            else:
-                setattr(raised_exception, name, attr)
-        except AttributeError:
-            # In case some things are read only
-            pass
-    s = json_obj.get(FIELD_EXC_STR)
-    if s:
-        try:
-            if "__str__" in raised_exception.__user_defined__:
-                setattr(raised_exception, "_original___str__", s)
-            else:
-                setattr(raised_exception, "__str__", lambda x, s=s: s)
-        except AttributeError:
-            raised_exception._missing_str = True
-    s = json_obj.get(FIELD_EXC_REPR)
-    if s:
-        try:
-            if "__repr__" in raised_exception.__user_defined__:
-                setattr(raised_exception, "_original___repr__", s)
-            else:
-                setattr(raised_exception, "__repr__", lambda x, s=s: s)
-        except AttributeError:
-            raised_exception._missing_repr = True
+    # This name is already cannonical since we cannonicalize it on the server side
+    full_name = "%s.%s" % (exception_module, exception_name)
+
+    exception_class = client.get_local_class(full_name, is_returned_exception=True)
+
+    if issubclass(exception_class, Stub):
+        raised_exception = exception_class(_is_returned_exception=True)
+        raised_exception.args = tuple(json_obj.get(FIELD_EXC_ARGS))
+    else:
+        raised_exception = exception_class(*json_obj.get(FIELD_EXC_ARGS))
+    raised_exception._exception_str = json_obj.get(FIELD_EXC_STR, None)
+    raised_exception._exception_repr = json_obj.get(FIELD_EXC_REPR, None)
+    raised_exception._exception_tb = json_obj.get(FIELD_EXC_TB, None)
+
     user_args = json_obj.get(FIELD_EXC_USER)
     if user_args is not None:
-        try:
-            deserializer = getattr(raised_exception, "_deserialize_user")
-        except AttributeError:
-            raised_exception._missing_deserializer = True
-        else:
-            deserializer(user_args)
-    raised_exception._remote_tb = json_obj[FIELD_EXC_TB]
+        deserializer = client.get_exception_deserializer(full_name)
+        if deserializer is not None:
+            deserializer(raised_exception, user_args)
     return raised_exception
 
 
-def _wrap_exception(exception_class):
-    to_return = _derived_exceptions.get(exception_class)
-    if to_return is not None:
-        return to_return
-
-    class WithPrettyPrinting(exception_class):
-        def __str__(self):
-            try:
-                text = super(WithPrettyPrinting, self).__str__()
-            except:  # noqa E722
-                text = "<Garbled exception>"
-            # if getattr(self, "_missing_deserializer", False):
-            #     text += (
-            #         "\n\n===== WARNING: User data from the exception was not deserialized "
-            #         "-- possible missing information =====\n"
-            #     )
-            # if getattr(self, "_missing_str", False):
-            #     text += "\n\n===== WARNING: Could not set class specific __str__ "
-            #     "-- possible missing information =====\n"
-            # if getattr(self, "_missing_repr", False):
-            #     text += "\n\n===== WARNING: Could not set class specific __repr__ "
-            #     "-- possible missing information =====\n"
-            remote_tb = getattr(self, "_remote_tb", "No remote traceback available")
+class ExceptionMetaClass(type):
+    def __init__(cls, class_name, base_classes, class_dict):
+        super(ExceptionMetaClass, cls).__init__(class_name, base_classes, class_dict)
+        cls.__orig_str__ = cls.__str__
+        cls.__orig_repr__ = cls.__repr__
+        for n in ("_exception_str", "_exception_repr", "_exception_tb"):
+            setattr(
+                cls,
+                n,
+                property(
+                    lambda self, n=n: getattr(self, "%s_val" % n, "<missing>"),
+                    lambda self, v, n=n: setattr(self, "%s_val" % n, v),
+                ),
+            )
+
+        def _do_str(self):
+            text = self._exception_str
             text += "\n\n===== Remote (on server) traceback =====\n"
-            text += remote_tb
+            text += self._exception_tb
             text += "========================================\n"
             return text
 
-    WithPrettyPrinting.__name__ = exception_class.__name__
-    WithPrettyPrinting.__module__ = exception_class.__module__
-    WithPrettyPrinting.__realclass__ = exception_class
-    _derived_exceptions[exception_class] = WithPrettyPrinting
-    return WithPrettyPrinting
+        cls.__str__ = _do_str
+        cls.__repr__ = lambda self: self._exception_repr
 
 
 class RemoteInterpreterException(Exception):
-    """A 'generic exception' that is raised when the exception the gotten from
-    the remote server cannot be instantiated locally"""
+    """
+    A 'generic' exception that was raised on the server side for which we have no
+    equivalent exception on this side
+    """
 
     pass
-
-
-_remote_exceptions_class = {}  # Exception name -> type of that exception
-_derived_exceptions = {}

metaflow/plugins/env_escape/override_decorators.py

@@ -110,18 +110,18 @@ def remote_setattr_override(obj_mapping):
     return _wrapped
 
 
-class LocalException(object):
-    def __init__(self, class_path, wrapped_class):
+class LocalExceptionDeserializer(object):
+    def __init__(self, class_path, deserializer):
         self._class_path = class_path
-        self._class = wrapped_class
+        self._deserializer = deserializer
 
     @property
     def class_path(self):
         return self._class_path
 
     @property
-    def wrapped_class(self):
-        return self._class
+    def deserializer(self):
+        return self._deserializer
 
 
 class RemoteExceptionSerializer(object):
@@ -138,9 +138,9 @@ class RemoteExceptionSerializer(object):
         return self._serializer
 
 
-def local_exception(class_path):
-    def _wrapped(cls):
-        return LocalException(class_path, cls)
+def local_exception_deserialize(class_path):
+    def _wrapped(func):
+        return LocalExceptionDeserializer(class_path, func)
 
     return _wrapped
 

metaflow/plugins/env_escape/server.py

@@ -36,6 +36,7 @@ from .consts import (
     OP_GETVAL,
     OP_SETVAL,
     OP_INIT,
+    OP_SUBCLASSCHECK,
     VALUE_LOCAL,
     VALUE_REMOTE,
     CONTROL_GETEXPORTS,
@@ -113,9 +114,21 @@ class Server(object):
                     # this by listing aliases in the same order so we don't support
                     # it for now.
                     raise ValueError(
-                        "%s is an alias to both %s and %s" % (alias, base_name, a)
+                        "%s is an alias to both %s and %s -- make sure all aliases "
+                        "are listed in the same order" % (alias, base_name, a)
                     )
 
+        # Detect circular aliases. If a user lists ("a", "b") and then ("b", "a"), we
+        # will have an entry in aliases saying b is an alias for a and a is an alias
+        # for b which is a recipe for disaster since we no longer have a cannonical name
+        # for things.
+        for alias, base_name in self._aliases.items():
+            if base_name in self._aliases:
+                raise ValueError(
+                    "%s and %s are circular aliases -- make sure all aliases "
+                    "are listed in the same order" % (alias, base_name)
+                )
+
         # Determine if we have any overrides
         self._overrides = {}
         self._getattr_overrides = {}
@@ -124,8 +137,9 @@ class Server(object):
         for override in override_values:
             if isinstance(override, (RemoteAttrOverride, RemoteOverride)):
                 for obj_name, obj_funcs in override.obj_mapping.items():
+                    canonical_name = get_canonical_name(obj_name, self._aliases)
                     obj_type = self._known_classes.get(
-                        obj_name, self._proxied_types.get(obj_name)
+                        canonical_name, self._proxied_types.get(obj_name)
                     )
                     if obj_type is None:
                         raise ValueError(
@@ -146,11 +160,17 @@ class Server(object):
                             )
                         override_dict[name] = override.func
             elif isinstance(override, RemoteExceptionSerializer):
+                canonical_name = get_canonical_name(override.class_path, self._aliases)
+                if canonical_name not in self._known_exceptions:
+                    raise ValueError(
+                        "%s does not refer to an exported exception"
+                        % override.class_path
+                    )
                 if override.class_path in self._exception_serializers:
                     raise ValueError(
                         "%s exception serializer already defined" % override.class_path
                     )
-                self._exception_serializers[override.class_path] = override.serializer
+                self._exception_serializers[canonical_name] = override.serializer
 
         # Process the exceptions making sure we have all the ones we need and building a
         # topologically sorted list for the client to instantiate
@@ -181,8 +201,8 @@ class Server(object):
                     else:
                         raise ValueError(
                             "Exported exception %s has non exported and non builtin parent "
-                            "exception: %s. Known exceptions: %s"
-                            % (ex_name, fqn, str(self._known_exceptions))
+                            "exception: %s (%s). Known exceptions: %s."
+                            % (ex_name, fqn, canonical_fqn, str(self._known_exceptions))
                         )
             name_to_parent_count[ex_name_canonical] = len(parents) - 1
             name_to_parents[ex_name_canonical] = parents
@@ -236,6 +256,7 @@ class Server(object):
             OP_GETVAL: self._handle_getval,
             OP_SETVAL: self._handle_setval,
             OP_INIT: self._handle_init,
+            OP_SUBCLASSCHECK: self._handle_subclasscheck,
         }
 
         self._local_objects = {}
@@ -273,6 +294,7 @@ class Server(object):
     def encode_exception(self, ex_type, ex, trace_back):
         try:
             full_name = "%s.%s" % (ex_type.__module__, ex_type.__name__)
+            get_canonical_name(full_name, self._aliases)
             serializer = self._exception_serializers.get(full_name)
         except AttributeError:
             # Ignore if no __module__ for example -- definitely not something we built
@@ -483,6 +505,21 @@ class Server(object):
             raise ValueError("Unknown class %s" % class_name)
         return class_type(*args, **kwargs)
 
+    def _handle_subclasscheck(self, target, class_name, otherclass_name, reverse=False):
+        class_type = self._known_classes.get(class_name)
+        if class_type is None:
+            raise ValueError("Unknown class %s" % class_name)
+        try:
+            sub_module, sub_name = otherclass_name.rsplit(".", 1)
+            __import__(sub_module, None, None, "*")
+        except Exception:
+            sub_module = None
+        if sub_module is None:
+            return False
+        if reverse:
+            return issubclass(class_type, getattr(sys.modules[sub_module], sub_name))
+        return issubclass(getattr(sys.modules[sub_module], sub_name), class_type)
+
 
 if __name__ == "__main__":
     max_pickle_version = int(sys.argv[1])

metaflow/plugins/env_escape/stub.py

@@ -1,5 +1,6 @@
 import functools
 import pickle
+from typing import Any
 
 from .consts import (
     OP_GETATTR,
@@ -15,8 +16,11 @@ from .consts import (
     OP_PICKLE,
     OP_DIR,
     OP_INIT,
+    OP_SUBCLASSCHECK,
 )
 
+from .exception_transferer import ExceptionMetaClass
+
 DELETED_ATTRS = frozenset(["__array_struct__", "__array_interface__"])
 
 # These attributes are accessed directly on the stub (not directly forwarded)
@@ -26,7 +30,10 @@ LOCAL_ATTRS = (
             "___remote_class_name___",
             "___identifier___",
             "___connection___",
-            "___local_overrides___" "__class__",
+            "___local_overrides___",
+            "___is_returned_exception___",
+            "___exception_attributes___",
+            "__class__",
             "__init__",
             "__del__",
             "__delattr__",
@@ -36,9 +43,11 @@ LOCAL_ATTRS = (
             "__getattribute__",
             "__hash__",
             "__instancecheck__",
+            "__subclasscheck__",
             "__init__",
             "__metaclass__",
             "__module__",
+            "__name__",
             "__new__",
             "__reduce__",
             "__reduce_ex__",
@@ -62,17 +71,19 @@ CLASS_METHOD = 2
 
 def fwd_request(stub, request_type, *args, **kwargs):
     connection = object.__getattribute__(stub, "___connection___")
-    return connection.stub_request(stub, request_type, *args, **kwargs)
+    if connection:
+        return connection.stub_request(stub, request_type, *args, **kwargs)
+    raise RuntimeError(
+        "Returned exception stub cannot be used to make further remote requests"
+    )
 
 
 class StubMetaClass(type):
-    __slots__ = ()
-
-    def __repr__(self):
-        if self.__module__:
-            return "<stub class '%s.%s'>" % (self.__module__, self.__name__)
+    def __repr__(cls):
+        if cls.__module__:
+            return "<stub class '%s.%s'>" % (cls.__module__, cls.__name__)
         else:
-            return "<stub class '%s'>" % (self.__name__,)
+            return "<stub class '%s'>" % (cls.__name__,)
 
 
 def with_metaclass(meta, *bases):
@@ -94,24 +105,25 @@ class Stub(with_metaclass(StubMetaClass, object)):
     happen on the remote side (server).
     """
 
-    __slots__ = [
-        "___remote_class_name___",
-        "___identifier___",
-        "___connection___",
-        "__weakref__",
-    ]
-
+    __slots__ = ()
     # def __iter__(self):  # FIXME: Keep debugger QUIET!!
     #    raise AttributeError
 
-    def __init__(self, connection, remote_class_name, identifier):
+    def __init__(
+        self, connection, remote_class_name, identifier, _is_returned_exception=False
+    ):
         self.___remote_class_name___ = remote_class_name
         self.___identifier___ = identifier
         self.___connection___ = connection
+        # If it is a returned exception (ie: it was raised by the server), it behaves
+        # a bit differently for methods like __str__ and __repr__ (we try not to get
+        # stuff from the server)
+        self.___is_returned_exception___ = _is_returned_exception
 
     def __del__(self):
         try:
-            fwd_request(self, OP_DEL)
+            if not self.___is_returned_exception___:
+                fwd_request(self, OP_DEL)
         except Exception:
             # raised in a destructor, most likely on program termination,
             # when the connection might have already been closed.
@@ -120,9 +132,7 @@ class Stub(with_metaclass(StubMetaClass, object)):
 
     def __getattribute__(self, name):
         if name in LOCAL_ATTRS:
-            if name == "__class__":
-                return None
-            elif name == "__doc__":
+            if name == "__doc__":
                 return self.__getattr__("__doc__")
             elif name in DELETED_ATTRS:
                 raise AttributeError()
@@ -144,10 +154,16 @@ class Stub(with_metaclass(StubMetaClass, object)):
         if name in LOCAL_ATTRS:
             object.__delattr__(self, name)
         else:
+            if self.___is_returned_exception___:
+                raise AttributeError()
             return fwd_request(self, OP_DELATTR, name)
 
     def __setattr__(self, name, value):
-        if name in LOCAL_ATTRS or name in self.___local_overrides___:
+        if (
+            name in LOCAL_ATTRS
+            or name in self.___local_overrides___
+            or self.___is_returned_exception___
+        ):
             object.__setattr__(self, name, value)
         else:
             fwd_request(self, OP_SETATTR, name, value)
@@ -159,9 +175,13 @@ class Stub(with_metaclass(StubMetaClass, object)):
         return fwd_request(self, OP_HASH)
 
     def __repr__(self):
+        if self.___is_returned_exception___:
+            return self.__exception_repr__()
         return fwd_request(self, OP_REPR)
 
     def __str__(self):
+        if self.___is_returned_exception___:
+            return self.__exception_str__()
         return fwd_request(self, OP_STR)
 
     def __exit__(self, exc, typ, tb):
@@ -173,6 +193,16 @@ class Stub(with_metaclass(StubMetaClass, object)):
         # support for pickling
         return pickle.loads, (fwd_request(self, OP_PICKLE, proto),)
 
+    @classmethod
+    def __subclasshook__(cls, parent):
+        if parent.__bases__[0] == Stub:
+            raise NotImplementedError  # Follow the usual mechanism
+        # If this is not a stub, we go over to the other side
+        parent_name = "%s.%s" % (parent.__module__, parent.__name__)
+        return cls.___class_connection___.stub_request(
+            None, OP_SUBCLASSCHECK, cls.___class_remote_class_name___, parent_name, True
+        )
+
 
 def _make_method(method_type, connection, class_name, name, doc):
     if name == "__call__":
@@ -248,6 +278,80 @@ class MetaWithConnection(StubMetaClass):
                 None, OP_INIT, cls.___class_remote_class_name___, *args, **kwargs
             )
 
+    def __subclasscheck__(cls, subclass):
+        subclass_name = "%s.%s" % (subclass.__module__, subclass.__name__)
+        if subclass.__bases__[0] == Stub:
+            subclass_name = subclass.___class_remote_class_name___
+        return cls.___class_connection___.stub_request(
+            None,
+            OP_SUBCLASSCHECK,
+            cls.___class_remote_class_name___,
+            subclass_name,
+        )
+
+    def __instancecheck__(cls, instance):
+        if type(instance) == cls:
+            # Fast path if it's just an object of this class
+            return True
+        # Goes to __subclasscheck__ above
+        return cls.__subclasscheck__(type(instance))
+
+
+class MetaExceptionWithConnection(StubMetaClass, ExceptionMetaClass):
+    def __new__(cls, class_name, base_classes, class_dict, connection):
+        return type.__new__(cls, class_name, base_classes, class_dict)
+
+    def __init__(cls, class_name, base_classes, class_dict, connection):
+        cls.___class_remote_class_name___ = class_name
+        cls.___class_connection___ = connection
+
+        # We call the one on ExceptionMetaClass which does everything needed (StubMetaClass
+        # does not do anything special for init)
+        ExceptionMetaClass.__init__(cls, class_name, base_classes, class_dict)
+
+        # Restore __str__ and __repr__ to the original ones because we need to determine
+        # if we call them depending on whether or not the object is a returned exception
+        # or not
+        cls.__exception_str__ = cls.__str__
+        cls.__exception_repr__ = cls.__repr__
+        cls.__str__ = cls.__orig_str__
+        cls.__repr__ = cls.__orig_repr__
+
+    def __call__(cls, *args, **kwargs):
+        # Very similar to the other case but we also need to be able to detect
+        # local instantiation of an exception so that we can set the __is_returned_exception__
+        if len(args) > 0 and id(args[0]) == id(cls.___class_connection___):
+            return super(MetaExceptionWithConnection, cls).__call__(*args, **kwargs)
+        elif kwargs and kwargs.get("_is_returned_exception", False):
+            return super(MetaExceptionWithConnection, cls).__call__(
+                None, None, None, _is_returned_exception=True
+            )
+        else:
+            return cls.___class_connection___.stub_request(
+                None, OP_INIT, cls.___class_remote_class_name___, *args, **kwargs
+            )
+
+    # The issue is that for a proxied object that is also an exception, we now have
+    # two classes representing it, one that includes the Stub class and one that doesn't
+    # Concretely:
+    #  - test.MyException would return a class that derives from Stub
+    #  - test.MySubException would return a class that derives from Stub and test.MyException
+    #    but WITHOUT the Stub portion (see get_local_class).
+    #  - we want issubclass(test.MySubException, test.MyException) to return True and
+    #    the same with instance checks.
+    def __instancecheck__(cls, instance):
+        return cls.__subclasscheck__(type(instance))
+
+    def __subclasscheck__(cls, subclass):
+        # __mro__[0] is this class itself
+        # __mro__[1] is the stub so we start checking at 2
+        return any(
+            [
+                subclass.__mro__[i] in cls.__mro__[2:]
+                for i in range(2, len(subclass.__mro__))
+            ]
+        )
+
 
 def create_class(
     connection,
@@ -256,8 +360,16 @@ def create_class(
     getattr_overrides,
     setattr_overrides,
     class_methods,
+    parents,
 ):
-    class_dict = {"__slots__": ()}
+    class_dict = {
+        "__slots__": [
+            "___remote_class_name___",
+            "___identifier___",
+            "___connection___",
+            "___is_returned_exception___",
+        ]
+    }
     for name, doc in class_methods.items():
         method_type = NORMAL_METHOD
         if name.startswith("___s___"):
@@ -318,5 +430,38 @@ def create_class(
             )
             overriden_attrs.add(attr)
         class_dict[attr] = property(getter, setter)
+    if parents:
+        # This means this is also an exception so we add a few more things to it
+        # so that it
+        # This is copied from ExceptionMetaClass in exception_transferer.py
+        for n in ("_exception_str", "_exception_repr", "_exception_tb"):
+            class_dict[n] = property(
+                lambda self, n=n: getattr(self, "%s_val" % n, "<missing>"),
+                lambda self, v, n=n: setattr(self, "%s_val" % n, v),
+            )
+
+        def _do_str(self):
+            text = self._exception_str
+            text += "\n\n===== Remote (on server) traceback =====\n"
+            text += self._exception_tb
+            text += "========================================\n"
+            return text
+
+        class_dict["__exception_str__"] = _do_str
+        class_dict["__exception_repr__"] = lambda self: self._exception_repr
+    else:
+        # If we are based on an exception, we already have __weakref__ so we don't add
+        # it but not the case if we are not.
+        class_dict["__slots__"].append("__weakref__")
+
+    class_module, class_name_only = class_name.rsplit(".", 1)
     class_dict["___local_overrides___"] = overriden_attrs
-    return MetaWithConnection(class_name, (Stub,), class_dict, connection)
+    class_dict["__module__"] = class_module
+    if parents:
+        to_return = MetaExceptionWithConnection(
+            class_name, (Stub, *parents), class_dict, connection
+        )
+    else:
+        to_return = MetaWithConnection(class_name, (Stub,), class_dict, connection)
+    to_return.__name__ = class_name_only
+    return to_return