Remove superfluous code now MicroPython supports inspect API for function signature inspection. (#2387)

ntoll · web-flow · commit ffc78ab6a272 · 2025-10-08T09:27:53.000+01:00
* Remove superfluous code now MicroPython supports inspect API for function signature inspection. 
* Added test to ensure all callables are covered.
diff --git a/core/src/stdlib/pyscript.js b/core/src/stdlib/pyscript.js
diff --git a/core/src/stdlib/pyscript/events.py b/core/src/stdlib/pyscript/events.py
@@ -92,60 +92,26 @@ def when(target, *args, **kwargs):
             elements = selector if isinstance(selector, list) else [selector]
 
     def decorator(func):
-        if config["type"] == "mpy":  # Is MicroPython?
+        sig = inspect.signature(func)
+        if sig.parameters:
             if is_awaitable(func):
 
-                async def wrapper(*args, **kwargs):
-                    """
-                    This is  a very ugly hack to get micropython working because
-                    `inspect.signature` doesn't exist. It may be actually better
-                    to not try any magic for now and raise the error.
-                    """
-                    try:
-                        return await func(*args, **kwargs)
-
-                    except TypeError as e:
-                        if "takes" in str(e) and "positional arguments" in str(e):
-                            return await func()
-                        raise
+                async def wrapper(event):
+                    return await func(event)
 
             else:
-
-                def wrapper(*args, **kwargs):
-                    """
-                    This is  a very ugly hack to get micropython working because
-                    `inspect.signature` doesn't exist. It may be actually better
-                    to not try any magic for now and raise the error.
-                    """
-                    try:
-                        return func(*args, **kwargs)
-
-                    except TypeError as e:
-                        if "takes" in str(e) and "positional arguments" in str(e):
-                            return func()
-                        raise
-
+                wrapper = func
         else:
-            sig = inspect.signature(func)
-            if sig.parameters:
-                if is_awaitable(func):
+            # Function doesn't receive events.
+            if is_awaitable(func):
 
-                    async def wrapper(event):
-                        return await func(event)
+                async def wrapper(*args, **kwargs):
+                    return await func()
 
-                else:
-                    wrapper = func
             else:
-                # Function doesn't receive events.
-                if is_awaitable(func):
-
-                    async def wrapper(*args, **kwargs):
-                        return await func()
 
-                else:
-
-                    def wrapper(*args, **kwargs):
-                        return func()
+                def wrapper(*args, **kwargs):
+                    return func()
 
         wrapper = wraps(func)(wrapper)
         if isinstance(target, Event):
diff --git a/core/tests/python/tests/test_events.py b/core/tests/python/tests/test_events.py
@@ -358,3 +358,79 @@ def handler(result):
     # The function should have been called when the whenable object was
     # triggered.
     assert counter == 1
+
+def test_when_on_different_callables():
+    """
+    The when function works with:
+
+    * Synchronous functions
+    * Asynchronous functions
+    * Inner functions
+    * Async inner functions
+    * Closure functions
+    * Async closure functions
+    """
+
+    def func(x=1):
+        # A simple function.
+        return x
+
+    async def a_func(x=1):
+        # A simple async function.
+        return x
+
+    def make_inner_func():
+        # Creates a simple inner function.
+
+        def inner_func(x=1):
+            return x
+
+        return inner_func
+
+
+    def make_inner_a_func():
+        # Creates a simple async inner function.
+
+        async def inner_a_func(x=1):
+            return x
+
+        return inner_a_func
+
+
+    def make_closure():
+        # Creates a simple closure function.
+        a = 1
+
+        def closure_func(x=1):
+            return a + x
+
+        return closure_func
+
+
+    def make_a_closure():
+        # Creates a simple async closure function.
+        a = 1
+
+        async def closure_a_func(x=1):
+            return a + x
+
+        return closure_a_func
+
+
+    inner_func = make_inner_func()
+    inner_a_func = make_inner_a_func()
+    cl_func = make_closure()
+    cl_a_func = make_a_closure()
+
+
+    whenable  = Event()
+
+    # Each of these should work with the when function.
+    when(whenable, func)
+    when(whenable, a_func)
+    when(whenable, inner_func)
+    when(whenable, inner_a_func)
+    when(whenable, cl_func)
+    when(whenable, cl_a_func)
+    # If we get here, everything worked.
+    assert True
