feat(TrameApp): avoid intermediate class

Author: finetjul

tests/test_decorators.py

@@ -5,23 +5,39 @@ def test_TrameApp():
 
     @TrameApp()
     class A:
-        def __init__(self, server):
+        def __init__(self, server, e):
+            """doc string"""
             self.server = server
-            self.server.state.change("c")(self.c_changed)
-
-    class B(A):
-        def __init__(self, server):
-            super().__init__(server)
+            self.e = e
 
         @change("c")
         def c_changed(self, c, **kwargs):
             self.c = c
 
+    class B(A):
+        def __init__(self, server, e):
+            super().__init__(server, e)
+
+        @change("d")
+        def d_changed(self, d, **kwargs):
+            self.d = d
+
         @controller.set("on_server_ready")
         def on_server_ready(self, **kwargs):
             assert self.c == 10
+            assert self.d == 15
             asyncio.create_task(self.server.stop())
 
-    b = B(get_server())
+    server = get_server()
+
+    a = A(server, 1)
+    assert type(a) is A
+    assert a.__init__.__doc__ is not None
+
+    b = B(server, 2)
+    assert type(b) is B
+    assert b.e == 2
+
     b.server.state.c = 10
+    b.server.state.d = 15
     b.server.start()

trame/decorators/klass.py

@@ -42,61 +42,63 @@ def __init__(self, server="server", namespace=""):
         self.namespace_prefix = namespace
 
     def __call__(self, klass):
-        class TrameWrapper(klass):
-            @functools.wraps(klass, updated=())
-            def __init__(instance, *args, **kwargs):
-                logger.debug("Create instance")
-                super(TrameWrapper, instance).__init__(*args, **kwargs)
-
-                logger.debug("Instance created")
-
-                server = getattr(instance, self.server_name)
-                prefix = (
-                    getattr(instance, self.namespace_prefix)
-                    if self.namespace_prefix
-                    else ""
-                )
-
-                logger.debug(f"{server=} {prefix=}")
-
-                # Look for method decorator
-                for k in inspect.getmembers(instance.__class__, can_be_decorated):
-                    fn = getattr(instance, k[0])
-
-                    # Handle @state.change
-                    if "_trame_state_change" in fn.__dict__:
-                        state_change_names = fn.__dict__["_trame_state_change"]
-                        logger.debug(
-                            f"state.change({[f'{prefix}{v}' for v in state_change_names]})({k[0]})"
-                        )
-                        server.state.change(
-                            *[f"{prefix}{v}" for v in state_change_names]
-                        )(fn)
-
-                    # Handle @trigger
-                    if "_trame_trigger_names" in fn.__dict__:
-                        trigger_names = fn.__dict__["_trame_trigger_names"]
-                        for trigger_name in trigger_names:
-                            logger.debug(f"trigger({trigger_name})({k[0]})")
-                            server.trigger(f"{trigger_name}")(fn)
-                            if prefix:
-                                logger.debug(f"trigger({prefix}{trigger_name})({k[0]})")
-                                server.trigger(f"{prefix}{trigger_name}")(fn)
-
-                    # Handle @ctrl.[add, once, add_task, set]
-                    if "_trame_controller" in fn.__dict__:
-                        actions = fn.__dict__["_trame_controller"]
-                        for action in actions:
-                            name = action.get("name")
-                            method = action.get("method")
-                            decorate = getattr(server.controller, method)
-                            logger.debug(f"ctrl.{method}({name})({k[0]})")
-                            decorate(name)(fn)
-                            if prefix:
-                                logger.debug(f"ctrl.{method}({prefix}{name})({k[0]})")
-                                decorate(f"{prefix}{name}")(fn)
-
-        return TrameWrapper
+        self.klass_init = klass.__init__
+
+        @functools.wraps(klass.__init__, updated=())
+        def wrapped_init(instance, *args, **kwargs):
+            logger.debug("Create instance")
+            self.klass_init(instance, *args, **kwargs)
+
+            logger.debug("Instance created")
+
+            server = getattr(instance, self.server_name)
+            prefix = (
+                getattr(instance, self.namespace_prefix)
+                if self.namespace_prefix
+                else ""
+            )
+
+            logger.debug(f"{server=} {prefix=}")
+
+            # Look for method decorator
+            for k in inspect.getmembers(instance.__class__, can_be_decorated):
+                fn = getattr(instance, k[0])
+
+                # Handle @state.change
+                if "_trame_state_change" in fn.__dict__:
+                    state_change_names = fn.__dict__["_trame_state_change"]
+                    logger.debug(
+                        f"state.change({[f'{prefix}{v}' for v in state_change_names]})({k[0]})"
+                    )
+                    server.state.change(*[f"{prefix}{v}" for v in state_change_names])(
+                        fn
+                    )
+
+                # Handle @trigger
+                if "_trame_trigger_names" in fn.__dict__:
+                    trigger_names = fn.__dict__["_trame_trigger_names"]
+                    for trigger_name in trigger_names:
+                        logger.debug(f"trigger({trigger_name})({k[0]})")
+                        server.trigger(f"{trigger_name}")(fn)
+                        if prefix:
+                            logger.debug(f"trigger({prefix}{trigger_name})({k[0]})")
+                            server.trigger(f"{prefix}{trigger_name}")(fn)
+
+                # Handle @ctrl.[add, once, add_task, set]
+                if "_trame_controller" in fn.__dict__:
+                    actions = fn.__dict__["_trame_controller"]
+                    for action in actions:
+                        name = action.get("name")
+                        method = action.get("method")
+                        decorate = getattr(server.controller, method)
+                        logger.debug(f"ctrl.{method}({name})({k[0]})")
+                        decorate(name)(fn)
+                        if prefix:
+                            logger.debug(f"ctrl.{method}({prefix}{name})({k[0]})")
+                            decorate(f"{prefix}{name}")(fn)
+
+        klass.__init__ = wrapped_init
+        return klass
 
 
 def change(*args):