only argument

Author: getzze

src/psygnal/_evented_decorator.py

@@ -4,12 +4,11 @@
     Callable,
     Literal,
     Mapping,
-    Sequence,
     TypeVar,
     overload,
 )
 
-from psygnal._group_descriptor import EqOperator, SignalGroupDescriptor
+from psygnal._group_descriptor import EqOperator, FieldAliasFunc, SignalGroupDescriptor
 
 __all__ = ["evented"]
 
@@ -24,8 +23,7 @@ def evented(
     equality_operators: dict[str, EqOperator] | None = None,
     warn_on_no_fields: bool = ...,
     cache_on_instance: bool = ...,
-    signal_aliases: Mapping[str, str | None] | Callable[[str], str] | None = ...,
-    skip_signals: Sequence[str] | None = ...,
+    signal_aliases: Mapping[str, str | None] | FieldAliasFunc | None = ...,
 ) -> T: ...
 
 
@@ -37,8 +35,7 @@ def evented(
     equality_operators: dict[str, EqOperator] | None = None,
     warn_on_no_fields: bool = ...,
     cache_on_instance: bool = ...,
-    signal_aliases: Mapping[str, str | None] | Callable[[str], str] | None = ...,
-    skip_signals: Sequence[str] | None = ...,
+    signal_aliases: Mapping[str, str | None] | FieldAliasFunc | None = ...,
 ) -> Callable[[T], T]: ...
 
 
@@ -49,8 +46,7 @@ def evented(
     equality_operators: dict[str, EqOperator] | None = None,
     warn_on_no_fields: bool = True,
     cache_on_instance: bool = True,
-    signal_aliases: Mapping[str, str | None] | Callable[[str], str] | None = None,
-    skip_signals: Sequence[str] | None = None,
+    signal_aliases: Mapping[str, str | None] | FieldAliasFunc | None = None,
 ) -> Callable[[T], T] | T:
     """A decorator to add events to a dataclass.
 
@@ -90,14 +86,14 @@ def evented(
         access, but means that the owner instance will no longer be pickleable.  If
         `False`, the SignalGroup instance will *still* be cached, but not on the
         instance itself.
-    signal_aliases: Mapping[str, str | None] | None
-        If defined, a mapping between field name and signal name. Field that are not
-        defined as keys alias to the same name. If the value is None, the field does not
-        emit a changed signal when mutated. If None, defaults to an empty dict.
+    signal_aliases: Mapping[str, str | None] | Callable[[str], str | None] | None
+        If defined, a mapping between field name and signal name. Field names that are
+        not `signal_aliases` keys are not aliased (the signal name is the field name).
+        If the dict value is None, do not create a signal associated with this field.
+        If a callable, the signal name is the output of the function applied to the
+        field name. If the output is None, no signal is created for this field.
+        If None, defaults to an empty dict, no aliases.
         Default to None
-    skip_signals : Sequence[str], optional
-        A list of field names for which the creation of an associated Signal is skipped.
-        Default to []
 
     Returns
     -------
@@ -136,7 +132,6 @@ def _decorate(cls: T) -> T:
             warn_on_no_fields=warn_on_no_fields,
             cache_on_instance=cache_on_instance,
             signal_aliases=signal_aliases,
-            skip_signals=skip_signals,
         )
         # as a decorator, this will have already been called
         descriptor.__set_name__(cls, events_namespace)

src/psygnal/_group.py

@@ -335,7 +335,8 @@ def __init_subclass__(
                 stacklevel=2,
             )
 
-        cls._psygnal_aliases = {**signal_aliases}
+        aliases = getattr(cls, "_psygnal_aliases", {})
+        cls._psygnal_aliases = {**aliases, **signal_aliases}
 
         cls._psygnal_uniform = _is_uniform(cls._psygnal_signals.values())
         if strict and not cls._psygnal_uniform:

src/psygnal/_group_descriptor.py

@@ -14,7 +14,6 @@
     Iterable,
     Literal,
     Mapping,
-    Sequence,
     Type,
     TypeVar,
     cast,
@@ -33,6 +32,7 @@
 
 __all__ = ["is_evented", "get_evented_namespace", "EqOperator", "SignalGroupDescriptor"]
 
+FieldAliasFunc = Callable[[str], str | None]
 T = TypeVar("T", bound=Type)
 S = TypeVar("S")
 
@@ -150,8 +150,7 @@ def _build_dataclass_signal_group(
     cls: type,
     signal_group_class: type[SignalGroup] = SignalGroup,
     equality_operators: Iterable[tuple[str, EqOperator]] | None = None,
-    skip_signals: Sequence[str] | None = None,
-    signal_aliases: Mapping[str, str | None] | Callable[[str], str] = {},
+    signal_aliases: Mapping[str, str | None] | FieldAliasFunc | None = None,
 ) -> type[SignalGroup]:
     """Build a SignalGroup with events for each field in a dataclass.
 
@@ -166,33 +165,33 @@ def _build_dataclass_signal_group(
         If defined, a mapping of field name and equality operator to use to compare if
         each field was modified after being set.
         Default to None
-    skip_signals : Sequence[str] | None, optional
-        A list of field names for which the creation of an associated Signal is skipped.
+    signal_aliases: Mapping[str, str | None] | Callable[[str], str | None] | None
+        If defined, a mapping between field name and signal name. Field names that are
+        not `signal_aliases` keys are not aliased (the signal name is the field name).
+        If the dict value is None, do not create a signal associated with this field.
+        If a callable, the signal name is the output of the function applied to the
+        field name. If the output is None, no signal is created for this field.
+        If None, defaults to an empty dict, no aliases.
         Default to None
-    signal_aliases: Mapping[str, str | None]
-        A mapping between field name and signal name. Field that are not defined as keys
-        alias to the same name. If the value is None, the field does not emit a changed
-        signal when mutated.
-        Default to {}
 
     """
-    if skip_signals is None:
-        skip_signals = []
-    group_name = f"{cls.__name__}_{signal_group_class.__name__}"
+    group_name = f"{cls.__name__}{signal_group_class.__name__}"
+    # parse arguments
     _equality_operators = dict(equality_operators) if equality_operators else {}
+    eq_map = _get_eq_operator_map(cls)
     if callable(signal_aliases):
         transform = signal_aliases
         _signal_aliases = {}
     else:
         transform = _identity
         _signal_aliases = dict(signal_aliases) if signal_aliases else {}
+    signal_group_sig_names = list(getattr(signal_group_class, "_psygnal_signals", {}))
+
     signals = {}
-    eq_map = _get_eq_operator_map(cls)
     # create a Signal for each field in the dataclass
     for f in iter_fields_with_options(cls):
-        # Convert and validate private fields
-        if f.skip or f.name in skip_signals:
-            # Skip this field
+        # skip this field
+        if f.skip:
             continue
 
         # Equality operator
@@ -208,25 +207,22 @@ def _build_dataclass_signal_group(
             eq_map[f.name] = _pick_equality_operator(f.type_)
 
         # Signal name
+        sig_name: str | None
         if f.alias is not None:
             sig_name = f.alias
-        elif f.disable_setattr:
-            sig_name = f.name
         elif f.name in _signal_aliases:
-            sig_name_or_none = _signal_aliases[f.name]
-            if sig_name_or_none is None:
-                # original name, but it will be ignored when setattr
-                sig_name = f.name
-            else:
-                sig_name = sig_name_or_none
+            sig_name = _signal_aliases[f.name]
         else:
             sig_name = transform(f.name)
 
         # Add the field and signal name to the table of signals, to emit with `setattr`
-        if f.disable_setattr:
-            _signal_aliases[f.name] = None
-        elif f.name not in _signal_aliases:
-            _signal_aliases[f.name] = sig_name
+        # If the field has `disable_setattr`, the signal will be created, but it will
+        # not be called as the alias is set to None.
+        _signal_aliases[f.name] = sig_name if not f.disable_setattr else None
+
+        # Skip creating the signal
+        if sig_name is None:
+            continue
 
         # Repeated signal
         if sig_name in signals:
@@ -238,6 +234,13 @@ def _build_dataclass_signal_group(
                 stacklevel=2,
             )
             continue
+        if sig_name in signal_group_sig_names:
+            warnings.warn(
+                f"Skip signal {sig_name}, was already defined by {signal_group_class}",
+                UserWarning,
+                stacklevel=2,
+            )
+            continue
 
         # Create the Signal
         field_type = object if f.type_ is None else f.type_
@@ -443,14 +446,14 @@ def __setattr__(self, name: str, value: Any) -> None:
         events when fields change.  If `False`, no `__setattr__` method will be
         created.  (This will prevent signal emission, and assumes you are using a
         different mechanism to emit signals when fields change.)
-    signal_aliases: Mapping[str, str | None] | None
-        If defined, a mapping between field name and signal name. Field that are not
-        defined as keys alias to the same name. If the value is None, the field does not
-        emit a changed signal when mutated. If None, defaults to an empty dict.
+    signal_aliases: Mapping[str, str | None] | Callable[[str], str | None] | None
+        If defined, a mapping between field name and signal name. Field names that are
+        not `signal_aliases` keys are not aliased (the signal name is the field name).
+        If the dict value is None, do not create a signal associated with this field.
+        If a callable, the signal name is the output of the function applied to the
+        field name. If the output is None, no signal is created for this field.
+        If None, defaults to an empty dict, no aliases.
         Default to None
-    skip_signals : Sequence[str], optional
-        A list of field names for which the creation of an associated Signal is skipped.
-        Default to []
 
     Examples
     --------
@@ -482,8 +485,7 @@ def __init__(
         patch_setattr: bool = True,
         signal_group_class: type[SignalGroup] = SignalGroup,
         collect_fields: bool = True,
-        signal_aliases: Mapping[str, str | None] | Callable[[str], str] | None = None,
-        skip_signals: Sequence[str] | None = None,
+        signal_aliases: Mapping[str, str | None] | FieldAliasFunc | None = None,
     ):
         self._name: str | None = None
         self._eqop = tuple(equality_operators.items()) if equality_operators else None
@@ -492,12 +494,7 @@ def __init__(
         self._patch_setattr = patch_setattr
         self._signal_group_class = signal_group_class
         self._collect_fields = collect_fields
-        self._skip_signals = list(skip_signals) if skip_signals else []
-        self._signal_aliases: dict[str, str | None] | Callable[[str], str] = (
-            signal_aliases
-            if callable(signal_aliases)
-            else (dict(signal_aliases) if signal_aliases else {})
-        )
+        self._signal_aliases = signal_aliases
 
         self._signal_groups: dict[int, type[SignalGroup]] = {}
 
@@ -582,11 +579,6 @@ def _create_group(self, owner: type) -> type[SignalGroup]:
                     "subclass of SignalGroup if collect_field_to_signals is False."
                 )
 
-            # Remove skipped signals
-            for sig in self._skip_signals:
-                if sig in Group._psygnal_signals:
-                    del Group._psygnal_signals[sig]  # type: ignore [attr-defined]
-
             # Add aliases
             if callable(self._signal_aliases):
                 warnings.warn(
@@ -596,16 +588,18 @@ def _create_group(self, owner: type) -> type[SignalGroup]:
                     stacklevel=2,
                 )
                 Group._psygnal_aliases = {}
-            else:
-                Group._psygnal_aliases = {**self._signal_aliases}
+            elif isinstance(self._signal_aliases, dict):
+                Group._psygnal_aliases = {
+                    **Group._psygnal_aliases,
+                    **self._signal_aliases,
+                }
 
         # Collect fields and create SignalGroup subclass
         else:
             Group = _build_dataclass_signal_group(
                 owner,
                 signal_group_class=self._signal_group_class,
                 equality_operators=self._eqop,
-                skip_signals=self._skip_signals,
                 signal_aliases=self._signal_aliases,
             )