Fix Event.emit dispatch bugs: empty kwargs list and positional arg duplication

Two bugs fixed:

1. connect(callback, []) with empty list silently dropped callbacks
   instead of connecting a no-argument wrapper. The len(kwargs) > 0
   guard skipped connection entirely.

2. In emit: positional args were incorrectly duplicated as keyword args
   for native psygnal callbacks, causing TypeError in callbacks like
   WidgetBase.disconnect() which accept *args but not **kwargs.
   Fixed by dispatching native callbacks with raw positional+keyword args
   and wrapper callbacks with keyword-only args.

Additionally, single positional emit args are now mapped to 'obj' keyword
for wrapper-based callbacks, matching the universal HyperSpy convention.

Add regression tests for Event.emit dispatch edge cases

- Empty kwargs list with no-arg wrapper
- Positional emit args not duplicated as keywords for native callbacks
- Positional emit args mapped to 'obj' keyword for wrapped callbacks

Assisted-by: opencode/glm-5.2

Author: ericpre

hyperspy/events.py

@@ -236,10 +236,19 @@ def emit(self, *args, **kwargs):
         ``_arguments``, if set) — matching the :meth:`trigger` behaviour
         for backward compatibility with code like ``emit(signal)``.
         """
-        # Map positional args to declared argument names (same as trigger())
-        if args and self._arguments:
-            for name, val in zip(self._arguments, args, strict=True):
-                kwargs.setdefault(name, val)
+        # Map positional args to keyword names for wrapper-based dispatch.
+        # "all"-mode callbacks (native psygnal) receive args as positional;
+        # "some"/"map" wrapper callbacks (lambda **kw) need every arg as keyword.
+        wrapper_kwargs = dict(kwargs)
+        if args:
+            if self._arguments:
+                for name, val in zip(self._arguments, args, strict=True):
+                    wrapper_kwargs.setdefault(name, val)
+            elif len(args) == 1:
+                wrapper_kwargs.setdefault("obj", args[0])
+            else:
+                for i, val in enumerate(args):
+                    wrapper_kwargs[f"_arg{i}"] = val
 
         if self._is_blocked or self._suppress:
             return
@@ -253,7 +262,7 @@ def emit(self, *args, **kwargs):
 
         # Debounce guard: defer emission, resetting timer on each call
         if self._debounce_interval is not None:
-            self._debounce_pending_kwargs = kwargs
+            self._debounce_pending_kwargs = wrapper_kwargs
             if self._debounce_timer is not None:
                 self._debounce_timer.cancel()
             self._debounce_timer = threading.Timer(
@@ -262,12 +271,28 @@ def emit(self, *args, **kwargs):
             self._debounce_timer.start()
             return
 
-        self._emit_dispatch(args, kwargs)
+        self._emit_dispatch(args, kwargs, wrapper_kwargs)
 
-    def _emit_dispatch(self, args, kwargs):
+    def _emit_dispatch(self, args, kwargs, wrapper_kwargs):
         """Core dispatch: validate, order, and invoke callbacks."""
+        # Determine which kwarg names came from positional arg mapping.
+        # These must NOT be passed as keywords to "all"-mode callbacks,
+        # since they're already passed positionally via *args.
+        pos_kwarg_names = set()
+        if args:
+            if self._arguments:
+                pos_kwarg_names = set(self._arguments[: len(args)])
+            elif len(args) == 1:
+                pos_kwarg_names = {"obj"}
+            else:
+                pos_kwarg_names = {f"_arg{i}" for i in range(len(args))}
+
         if self._arguments:
-            kwargs = self._validate_emit_kwargs(kwargs)
+            wrapper_kwargs = self._validate_emit_kwargs(wrapper_kwargs)
+            # Apply defaults back to the "all"-mode kwargs
+            for k, v in wrapper_kwargs.items():
+                if k not in pos_kwarg_names:
+                    kwargs.setdefault(k, v)
 
         # Snapshot slots so connect/disconnect during dispatch are safe.
         # Dispatch in legacy order: "all" → "some" → "map".  This
@@ -290,19 +315,25 @@ def _emit_dispatch(self, args, kwargs):
             else:  # "map"
                 map_callbacks.append(callback)
 
-        for callback in all_callbacks + some_callbacks + map_callbacks:
+        for callback in all_callbacks:
             original = self._find_original(callback)
             if original in self._suppressed_callbacks:
                 continue
             callback(*args, **kwargs)
 
+        for callback in some_callbacks + map_callbacks:
+            original = self._find_original(callback)
+            if original in self._suppressed_callbacks:
+                continue
+            callback(**wrapper_kwargs)
+
     def _debounce_fire(self):
         """Called by the debounce timer — fires the pending emission."""
         kwargs = self._debounce_pending_kwargs
         self._debounce_pending_kwargs = None
         self._debounce_timer = None
         if kwargs is not None:
-            self._emit_dispatch(kwargs)
+            self._emit_dispatch((), {}, kwargs)
 
     @contextmanager
     def throttle(self, interval):
@@ -458,14 +489,22 @@ def connect(self, function, kwargs="all", **psygnal_opts):
             self._slot_mode[wrapper] = "map"
 
         elif isinstance(kwargs, (list, tuple)):
-            # only make a wrapper when there are argument to pass
-            if len(kwargs) > 0:
-                spec = tuple(kwargs)
+            spec = tuple(kwargs)
+            if len(spec) > 0:
                 wrapper = self._make_list_wrapper(function, spec)
-                super().connect(wrapper, **psygnal_opts)
-                self._wrapper_map[function] = (wrapper, spec)
-                self._connected_originals.add(function)
-                self._slot_mode[wrapper] = "some"
+            else:
+                # Empty → pass no kwargs (wrapper discards all emit args)
+                def _make_empty_wrapper(fn):
+                    def _empty_wrapper(**kw):
+                        return fn()
+
+                    return _empty_wrapper
+
+                wrapper = _make_empty_wrapper(function)
+            super().connect(wrapper, **psygnal_opts)
+            self._wrapper_map[function] = (wrapper, spec)
+            self._connected_originals.add(function)
+            self._slot_mode[wrapper] = "some"
 
         else:
             raise ValueError("Invalid value passed to kwargs.")

hyperspy/tests/test_events.py

@@ -455,6 +455,67 @@ def lambda2(x=None, y=None, A=None, B=None):
             self.events.a.connect(lambda2)
             self.events.a.trigger(A="vA", B="vB")
 
+    def test_connect_empty_kwargs_connects(self):
+        # Regression: connect(callback, []) must connect a wrapper that
+        # calls callback with no arguments.  Previously, len(kwargs) > 0
+        # skipped the connection silently, so the callback never fired.
+        called = []
+
+        def callback_no_args():
+            called.append(True)
+
+        with pytest.warns(VisibleDeprecationWarning):
+            # Deprecated API — Event() and connect(kwargs=[]) both emit
+            e = Event(arguments=["A", "B"])
+            e.connect(callback_no_args, [])
+
+        with pytest.warns(VisibleDeprecationWarning):
+            # Deprecated API — trigger() emits
+            e.trigger(A="vA", B="vB")
+
+        assert len(called) == 1
+
+    def test_emit_positional_no_kwarg_duplication(self):
+        # Regression: emit(self) on an EventSignal without explicit
+        # arguments must pass the positional arg to native callbacks
+        # only as a positional arg, not also as a keyword "obj".
+        # Callbacks that accept *args but not **kwargs (like
+        # WidgetBase.disconnect) used to fail.
+        # self.events.c has _arguments is None.
+        e = self.events.c
+        received = []
+
+        def callback_starargs(*args):
+            received.append(args)
+
+        e.connect(callback_starargs)
+        sentinel = object()
+        e.emit(sentinel)
+        assert len(received) == 1
+        assert received[0][0] is sentinel
+        assert "obj" not in received[0]
+
+    def test_emit_positional_obj_for_wrapped_callback(self):
+        # When emit(self) is used on an EventSignal without explicit
+        # arguments, wrapper callbacks linked with connect(..., ["obj"])
+        # should receive the single positional arg as keyword "obj",
+        # matching the HyperSpy arg convention for events with
+        # explicit arguments=["obj"].
+        e = self.events.c
+        received = []
+
+        def callback_obj(obj):
+            received.append(obj)
+
+        with pytest.warns(VisibleDeprecationWarning):
+            # Deprecated API — connect(kwargs=["obj"])
+            e.connect(callback_obj, ["obj"])
+
+        sentinel = object()
+        e.emit(sentinel)
+        assert len(received) == 1
+        assert received[0] is sentinel
+
 
 # ---------------------------------------------------------------------------
 # Added regression tests — preserved deprecated behaviours and native API