Add automatic receiver setup for object methods in TSignal.connect

- Enhanced the connect method to automatically set the receiver for object methods that have the @t_with_signals decorator.
- Updated API documentation to reflect the new behavior of the connect method.
- Added unit tests to verify the functionality of automatic receiver setup.

Author: san-tekart

docs/api.md

@@ -92,6 +92,33 @@ Connects the signal to a slot.
   - `receiver_or_slot`: The callable (function, lambda, or method)
   - `slot`: None
 
+**Connection Behavior:**
+1. Object Method with Signal Support:
+   ```python
+   @t_with_signals
+   class Receiver:
+       def on_signal(self, value):
+           print(value)
+   
+   receiver = Receiver()
+   signal.connect(receiver.on_signal)  # Automatically sets up receiver
+   ```
+
+2. Regular Object Method:
+   ```python
+   class RegularClass:
+       def on_signal(self, value):
+           print(value)
+   
+   obj = RegularClass()
+   signal.connect(obj.on_signal)  # Treated as direct connection
+   ```
+
+The connection type is automatically determined:
+- Methods from objects with `@t_with_signals` are set up with their object as receiver
+- Regular object methods are treated as direct connections
+- Async methods always use queued connections
+
 ##### `disconnect(receiver: Optional[object] = None, slot: Optional[Callable] = None) -> int`
 Disconnects one or more slots from the signal.
 

src/tsignal/core.py

@@ -59,8 +59,20 @@ def connect(
                     f"Invalid connection attempt - receiver_or_slot is not callable: {receiver_or_slot}"
                 )
                 raise TypeError("When slot is not provided, receiver must be callable")
-            slot = _wrap_direct_function(receiver_or_slot)
+
             receiver = None
+
+            if hasattr(receiver_or_slot, "__self__"):
+                obj = receiver_or_slot.__self__
+                if hasattr(obj, _SignalConstants.THREAD) and hasattr(
+                    obj, _SignalConstants.LOOP
+                ):
+                    receiver = obj
+                    slot = receiver_or_slot
+                else:
+                    slot = _wrap_direct_function(receiver_or_slot)
+            else:
+                slot = _wrap_direct_function(receiver_or_slot)
         else:
             if receiver_or_slot is None:
                 logger.error("Invalid connection attempt - receiver cannot be None")

tests/unit/test_signal.py

@@ -216,3 +216,47 @@ def test_direct_function_disconnect(sender):
     # Second emit - should not add value since connection is disconnected
     sender.emit_value(43)
     assert received_values == [42]
+
+
+def test_method_connection_with_signal_attributes(sender):
+    """Test connecting a method with _thread and _loop attributes automatically sets up receiver"""
+    received_values = []
+
+    @t_with_signals
+    class SignalReceiver:
+        def collect_value(self, value):
+            received_values.append(value)
+
+    class RegularClass:
+        def collect_value(self, value):
+            received_values.append(value * 2)
+
+    # t_with_signals가 적용된 객체의 메소드
+    signal_receiver = SignalReceiver()
+    sender.value_changed.connect(signal_receiver.collect_value)
+
+    # 일반 객체의 메소드
+    regular_receiver = RegularClass()
+    sender.value_changed.connect(regular_receiver.collect_value)
+
+    # Emit signal
+    sender.emit_value(42)
+
+    # signal_receiver는 QueuedConnection으로 처리되어야 함
+    connection = next(
+        conn
+        for conn in sender.value_changed.connections
+        if conn[1] == signal_receiver.collect_value
+    )
+    assert connection[0] == signal_receiver  # receiver가 자동으로 설정됨
+
+    # regular_receiver는 DirectConnection으로 처리되어야 함
+    connection = next(
+        conn
+        for conn in sender.value_changed.connections
+        if hasattr(conn[1], "__wrapped__")
+    )
+    assert connection[0] is None  # receiver가 None임
+
+    assert 42 in received_values  # SignalReceiver의 결과
+    assert 84 in received_values  # RegularClass의 결과 (42 * 2)