add property

Author: san-tekart

docs/api.md

@@ -250,3 +250,45 @@ except AttributeError as e:
 except TypeError as e:
     logging.error(f"Invalid slot: {e}")
 ```
+
+## Slot Execution Behavior
+
+### Direct Slot Calls vs Signal Emissions
+
+Slots can be executed in two ways:
+
+#### Direct Calls
+```python
+# Synchronous slot direct call
+receiver.some_slot(value)  # Blocks until execution is complete
+
+# Asynchronous slot direct call 
+await receiver.async_slot(value)  # Can wait for completion with await
+```
+
+- Behaves like a regular function call
+- The calling thread blocks until execution is complete
+- For asynchronous slots, it can wait for completion using await
+- The same blocking behavior occurs when called from another thread
+
+#### Calls via Signal (emit)
+```python
+# Call via emit
+signal.emit(value)  # Returns immediately, executes asynchronously
+```
+
+- Executes asynchronously (returns immediately)
+- The slot is queued in the receiver's event loop
+- Does not wait for execution to complete
+- Disconnecting does not affect already queued slot executions
+
+Understanding these differences is particularly important in a multithreaded environment:
+```python
+# Direct call - waits for completion
+async def direct_call():
+    await receiver.async_slot()  # Blocks until complete
+
+# Emit - returns immediately
+def emit_call():
+    signal.emit()  # Returns immediately, slot executes in the background
+```

src/tsignal/__init__.py

@@ -7,6 +7,7 @@
     t_signal,
     t_slot,
     TConnectionType,
+    TSignalConstants,
 )
 from .contrib.patterns.worker.decorators import t_with_worker
 
@@ -18,4 +19,5 @@
     "t_slot",
     "t_with_worker",
     "TConnectionType",
+    "TSignalConstants",
 ]

src/tsignal/contrib/extensions/__init__.py

@@ -0,0 +1,3 @@
+from .property import t_property
+
+__all__ = ["t_property"]

src/tsignal/contrib/extensions/property.py

@@ -0,0 +1,77 @@
+import asyncio
+import threading
+import logging
+from tsignal.core import TSignalConstants
+
+# Initialize logger
+
+logger = logging.getLogger(__name__)
+
+
+class TProperty(property):
+    def __init__(self, fget=None, fset=None, fdel=None, doc=None, notify=None):
+        super().__init__(fget, fset, fdel, doc)
+        self.notify = notify
+        self._private_name = None
+
+    def __set_name__(self, owner, name):
+        self._private_name = f"_{name}"
+
+    def __set__(self, obj, value):
+        if self.fset is None:
+            raise AttributeError("can't set attribute")
+
+        # DEBUG: Thread safety verification logs
+        # logger.debug(f"Object thread: {obj._thread}")
+        # logger.debug(f"Current thread: {threading.current_thread()}")
+        # logger.debug(f"Object loop: {obj._loop}")
+
+        if (
+            hasattr(obj, TSignalConstants.THREAD)
+            and threading.current_thread() != obj._thread
+        ):
+            # Queue the setter call in the object's event loop
+            future = asyncio.run_coroutine_threadsafe(
+                self._set_value(obj, value), obj._loop
+            )
+            # Wait for completion like slot direct calls
+            return future.result()
+        else:
+            return self._set_value_sync(obj, value)
+
+    def _set_value_sync(self, obj, value):
+        old_value = self.__get__(obj, type(obj))
+        result = self.fset(obj, value)
+
+        if self.notify is not None and old_value != value:
+            try:
+                signal_name = getattr(self.notify, "signal_name", None)
+
+                if signal_name:
+                    signal = getattr(obj, signal_name)
+                    signal.emit(value)
+                else:
+                    raise AttributeError(f"No signal_name found in {self.notify}")
+
+            except AttributeError as e:
+                logger.warning(
+                    f"Property {self._private_name} notify attribute not found. Error: {str(e)}"
+                )
+                pass
+
+        return result
+
+    async def _set_value(self, obj, value):
+        return self._set_value_sync(obj, value)
+
+    def setter(self, fset):
+        return type(self)(self.fget, fset, self.fdel, self.__doc__, self.notify)
+
+
+def t_property(notify=None):
+    logger.debug(f"t_property: {notify}")
+
+    def decorator(func):
+        return TProperty(fget=func, notify=notify)
+
+    return decorator

src/tsignal/core.py

@@ -11,16 +11,19 @@
 import threading
 from enum import Enum
 from typing import Callable, List, Tuple, Optional, Union
+import concurrent.futures
 
 
 class TConnectionType(Enum):
     """Connection type for signal-slot connections."""
+
     DIRECT_CONNECTION = 1
     QUEUED_CONNECTION = 2
 
 
-class _SignalConstants:
+class TSignalConstants:
     """Constants for signal-slot communication."""
+
     FROM_EMIT = "_from_emit"
     THREAD = "_thread"
     LOOP = "_loop"
@@ -38,7 +41,7 @@ def _wrap_direct_function(func):
     def wrapper(*args, **kwargs):
         """Wrapper for directly connected functions"""
         # Remove FROM_EMIT
-        kwargs.pop(_SignalConstants.FROM_EMIT, False)
+        kwargs.pop(TSignalConstants.FROM_EMIT, False)
 
         # DIRECT_CONNECTION executes immediately regardless of thread
         if is_coroutine:
@@ -55,6 +58,7 @@ def wrapper(*args, **kwargs):
 
 class TSignal:
     """Signal class for tsignal."""
+
     def __init__(self):
         self.connections: List[Tuple[Optional[object], Callable, TConnectionType]] = []
 
@@ -74,8 +78,8 @@ def connect(
 
             if hasattr(receiver_or_slot, "__self__"):
                 obj = receiver_or_slot.__self__
-                if hasattr(obj, _SignalConstants.THREAD) and hasattr(
-                    obj, _SignalConstants.LOOP
+                if hasattr(obj, TSignalConstants.THREAD) and hasattr(
+                    obj, TSignalConstants.LOOP
                 ):
                     receiver = obj
                     slot = receiver_or_slot
@@ -161,17 +165,24 @@ def call_wrapper(s=slot):
                 logger.error("Error in signal emission: %s", e, exc_info=True)
 
 
+class TSignalProperty(property):
+    def __init__(self, fget, signal_name):
+        super().__init__(fget)
+        self.signal_name = signal_name
+
+
 def t_signal(func):
     """Signal decorator"""
     sig_name = func.__name__
 
-    @property
+    # Using @property for lazy initialization of the signal.
+    # The signal object is created only when first accessed, and a cached object is returned thereafter.
     def wrapper(self):
         if not hasattr(self, f"_{sig_name}"):
             setattr(self, f"_{sig_name}", TSignal())
         return getattr(self, f"_{sig_name}")
 
-    return wrapper
+    return TSignalProperty(wrapper, sig_name)
 
 
 def t_slot(func):
@@ -183,12 +194,12 @@ def t_slot(func):
         @functools.wraps(func)
         async def wrapper(self, *args, **kwargs):
             """Wrapper for coroutine slots"""
-            from_emit = kwargs.pop(_SignalConstants.FROM_EMIT, False)
+            from_emit = kwargs.pop(TSignalConstants.FROM_EMIT, False)
 
-            if not hasattr(self, _SignalConstants.THREAD):
+            if not hasattr(self, TSignalConstants.THREAD):
                 self._thread = threading.current_thread()
 
-            if not hasattr(self, _SignalConstants.LOOP):
+            if not hasattr(self, TSignalConstants.LOOP):
                 try:
                     self._loop = asyncio.get_running_loop()
                 except RuntimeError:
@@ -211,12 +222,12 @@ async def wrapper(self, *args, **kwargs):
         @functools.wraps(func)
         def wrapper(self, *args, **kwargs):
             """Wrapper for regular slots"""
-            from_emit = kwargs.pop(_SignalConstants.FROM_EMIT, False)
+            from_emit = kwargs.pop(TSignalConstants.FROM_EMIT, False)
 
-            if not hasattr(self, _SignalConstants.THREAD):
+            if not hasattr(self, TSignalConstants.THREAD):
                 self._thread = threading.current_thread()
 
-            if not hasattr(self, _SignalConstants.LOOP):
+            if not hasattr(self, TSignalConstants.LOOP):
                 try:
                     self._loop = asyncio.get_running_loop()
                 except RuntimeError:
@@ -227,8 +238,18 @@ def wrapper(self, *args, **kwargs):
                 current_thread = threading.current_thread()
                 if current_thread != self._thread:
                     logger.debug("Executing regular slot from different thread")
-                    self._loop.call_soon_threadsafe(lambda: func(self, *args, **kwargs))
-                    return None
+                    # 동기 함수는 loop.call_soon_threadsafe와 Future를 사용
+                    future = concurrent.futures.Future()
+
+                    def callback():
+                        try:
+                            result = func(self, *args, **kwargs)
+                            future.set_result(result)
+                        except Exception as e:
+                            future.set_exception(e)
+
+                    self._loop.call_soon_threadsafe(callback)
+                    return future.result()
 
             return func(self, *args, **kwargs)
 
@@ -240,6 +261,7 @@ def t_with_signals(cls):
     original_init = cls.__init__
 
     def __init__(self, *args, **kwargs):
+        logger.debug("t_with_signals __init__")
         # Set thread and event loop
         self._thread = threading.current_thread()
         try:

tests/conftest.py

@@ -20,6 +20,12 @@
 logger = logging.getLogger(__name__)
 
 
+def log_debug(message):
+    """Log a debug message if DEBUG level is enabled."""
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(message)
+
+
 @pytest.fixture(scope="function")
 def event_loop():
     """Create an event loop"""
@@ -28,9 +34,11 @@ def event_loop():
     yield loop
     loop.close()
 
+
 @t_with_signals
 class Sender:
     """Sender class"""
+
     @t_signal
     def value_changed(self, value):
         """Signal for value changes"""
@@ -39,9 +47,11 @@ def emit_value(self, value):
         """Emit a value change signal"""
         self.value_changed.emit(value)
 
+
 @t_with_signals
 class Receiver:
     """Receiver class"""
+
     def __init__(self):
         super().__init__()
         self.received_value = None
@@ -52,25 +62,33 @@ def __init__(self):
     @t_slot
     async def on_value_changed(self, value: int):
         """Slot for value changes"""
-        logger.info("Receiver[%d] on_value_changed called with value: %d", self.id, value)
+        logger.info(
+            "Receiver[%d] on_value_changed called with value: %d", self.id, value
+        )
         logger.info("Current thread: %s", threading.current_thread().name)
         logger.info("Current event loop: %s", asyncio.get_running_loop())
         self.received_value = value
         self.received_count += 1
         logger.info(
             "Receiver[%d] updated: value=%d, count=%d",
-            self.id, self.received_value, self.received_count
+            self.id,
+            self.received_value,
+            self.received_count,
         )
 
     @t_slot
     def on_value_changed_sync(self, value: int):
         """Sync slot for value changes"""
-        logger.info("Receiver[%d] on_value_changed_sync called with value: %d", self.id, value)
+        logger.info(
+            "Receiver[%d] on_value_changed_sync called with value: %d", self.id, value
+        )
         self.received_value = value
         self.received_count += 1
         logger.info(
             "Receiver[%d] updated (sync): value=%d, count=%d",
-            self.id, self.received_value, self.received_count
+            self.id,
+            self.received_value,
+            self.received_count,
         )
 
 
@@ -101,6 +119,7 @@ def setup_logging():
         default_level = logging.DEBUG
 
     root.setLevel(default_level)
+    logger.debug("Logging level set to: %s", default_level)
 
     # Removing existing handlers
     for handler in root.handlers: