Enhance code quality and linting across the project

- Updated connection type constants to use uppercase naming convention (e.g., `DirectConnection` to `DIRECT_CONNECTION`).
- Improved logging statements for consistency and clarity, using formatted strings.
- Added docstrings to classes and methods for better documentation and understanding of the code.
- Removed unnecessary imports and simplified code where applicable.
- Ensured all async methods are properly defined and documented.
- Adjusted test cases to improve readability and maintainability.
- Configured pylint to disable specific warnings to streamline code quality checks.

Author: san-tekart

docs/api.md

@@ -172,8 +172,8 @@ Emits the signal with the given arguments.
 Enum defining connection types.
 
 #### Values:
-- `DirectConnection`: Slot is called directly in the emitting thread
-- `QueuedConnection`: Slot is queued in the receiver's event loop
+- `DIRECT_CONNECTION`: Slot is called directly in the emitting thread
+- `QUEUED_CONNECTION`: Slot is queued in the receiver's event loop
 
 ## Usage Examples
 
@@ -222,14 +222,14 @@ asyncio.run(main())
 sender.value_changed.connect(
     receiver,
     receiver.on_value_changed,
-    connection_type=TConnectionType.DirectConnection
+    connection_type=TConnectionType.DIRECT_CONNECTION
 )
 
 # Force queued connection
 sender.value_changed.connect(
     receiver,
     receiver.on_value_changed,
-    connection_type=TConnectionType.QueuedConnection
+    connection_type=TConnectionType.QUEUED_CONNECTION
 )
 ```
 

docs/usage.md

@@ -75,18 +75,18 @@ class DataProcessor:
 ## Connection Types
 TSignal supports two types of connections:
 
-### DirectConnection
+### DIRECT_CONNECTION
 - Signal and slot execute in the same thread
 - Slot is called immediately when signal is emitted
 ```python
-signal.connect(receiver, slot, connection_type=TConnectionType.DirectConnection)
+signal.connect(receiver, slot, connection_type=TConnectionType.DIRECT_CONNECTION)
 ```
 
-### QueuedConnection
+### QUEUED_CONNECTION
 - Signal and slot can execute in different threads
 - Slot execution is queued in receiver's event loop
 ```python
-signal.connect(receiver, slot, connection_type=TConnectionType.QueuedConnection)
+signal.connect(receiver, slot, connection_type=TConnectionType.QUEUED_CONNECTION)
 ```
 
 Connection type is automatically determined based on:

pyproject.toml

@@ -56,6 +56,14 @@ asyncio_default_fixture_loop_scope = "function"
 source = ["tsignal"]
 branch = true
 
+[tool.pylint]
+disable = [
+    "protected-access",
+    "too-few-public-methods",
+    "too-many-statements",
+    "broad-exception-caught"
+]
+
 [tool.coverage.report]
 exclude_lines = [
     "pragma: no cover",

src/tsignal/contrib/patterns/worker/decorators.py

@@ -1,19 +1,28 @@
+"""
+Decorator for the worker pattern.
+
+This decorator enhances a class to support a worker pattern, allowing for
+asynchronous task processing in a separate thread. It ensures that the
+class has the required asynchronous `initialize` and `finalize` methods,
+facilitating the management of worker threads and task queues.
+"""
+
 import asyncio
 import threading
 import logging
-import time
-import sys
 
 logger = logging.getLogger(__name__)
 
 
 def t_with_worker(cls):
+    """Decorator for the worker pattern."""
     if not asyncio.iscoroutinefunction(getattr(cls, "initialize", None)):
         raise TypeError(f"{cls.__name__}.initialize must be an async function")
     if not asyncio.iscoroutinefunction(getattr(cls, "finalize", None)):
         raise TypeError(f"{cls.__name__}.finalize must be an async function")
 
     class WorkerClass(cls):
+        """Worker class for the worker pattern."""
         def __init__(self):
             self._worker_loop = None
             self._worker_thread = None
@@ -22,10 +31,7 @@ def __init__(self):
             self._thread = threading.current_thread()
             try:
                 self._loop = asyncio.get_event_loop()
-                if sys.version_info < (3, 9):
-                    self._stopping = asyncio.Event(loop=self._loop)
-                else:
-                    self._stopping = asyncio.Event()
+                self._stopping = asyncio.Event()
             except RuntimeError:
                 self._loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(self._loop)
@@ -45,9 +51,10 @@ async def _process_queue(self):
                 except asyncio.TimeoutError:
                     continue
                 except Exception as e:
-                    logger.error(f"Error processing queued task: {e}")
+                    logger.error("Error processing queued task: %s", e)
 
         def start(self, *args, **kwargs):
+            """Start the worker thread."""
             if self._worker_thread:
                 raise RuntimeError("Worker already started")
 
@@ -78,12 +85,6 @@ async def run_loop():
                             if hasattr(self, "finalize"):
                                 await self.finalize()
 
-                                initial_pending = [
-                                    task
-                                    for task in asyncio.all_tasks(self._worker_loop)
-                                    if task is not asyncio.current_task()
-                                ]
-
                                 # Wait until all callbacks in the current event loop are processed
                                 while self._worker_loop.is_running():
                                     pending_tasks = [
@@ -115,6 +116,7 @@ async def run_loop():
             self._worker_thread.start()
 
         def stop(self):
+            """Stop the worker thread."""
             if (
                 self._worker_loop
                 and self._worker_thread
@@ -125,7 +127,8 @@ def stop(self):
 
                 if self._worker_thread and self._worker_thread.is_alive():
                     logger.warning(
-                        f"Worker thread {self._worker_thread.name} did not stop gracefully"
+                        "Worker thread %s did not stop gracefully",
+                        self._worker_thread.name,
                     )
                     self._worker_thread = None
 

src/tsignal/core.py

@@ -1,4 +1,10 @@
-# Standard library imports
+"""
+Implementation of the Signal class for tsignal.
+
+Provides signal-slot communication pattern for event handling, supporting both
+synchronous and asynchronous operations in a thread-safe manner.
+"""
+
 import asyncio
 import functools
 import logging
@@ -8,11 +14,13 @@
 
 
 class TConnectionType(Enum):
-    DirectConnection = 1
-    QueuedConnection = 2
+    """Connection type for signal-slot connections."""
+    DIRECT_CONNECTION = 1
+    QUEUED_CONNECTION = 2
 
 
 class _SignalConstants:
+    """Constants for signal-slot communication."""
     FROM_EMIT = "_from_emit"
     THREAD = "_thread"
     LOOP = "_loop"
@@ -28,10 +36,11 @@ def _wrap_direct_function(func):
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
+        """Wrapper for directly connected functions"""
         # Remove FROM_EMIT
         kwargs.pop(_SignalConstants.FROM_EMIT, False)
 
-        # DirectConnection executes immediately regardless of thread
+        # DIRECT_CONNECTION executes immediately regardless of thread
         if is_coroutine:
             try:
                 loop = asyncio.get_event_loop()
@@ -45,8 +54,8 @@ def wrapper(*args, **kwargs):
 
 
 class TSignal:
+    """Signal class for tsignal."""
     def __init__(self):
-        """Initialize signal"""
         self.connections: List[Tuple[Optional[object], Callable, TConnectionType]] = []
 
     def connect(
@@ -56,7 +65,8 @@ def connect(
         if slot is None:
             if not callable(receiver_or_slot):
                 logger.error(
-                    f"Invalid connection attempt - receiver_or_slot is not callable: {receiver_or_slot}"
+                    "Invalid connection attempt - receiver_or_slot is not callable: %s",
+                    receiver_or_slot,
                 )
                 raise TypeError("When slot is not provided, receiver must be callable")
 
@@ -80,15 +90,16 @@ def connect(
             receiver = receiver_or_slot
             if not callable(slot):
                 logger.error(
-                    f"Invalid connection attempt - slot is not callable: {slot}"
+                    "Invalid connection attempt - slot is not callable: %s",
+                    slot,
                 )
                 raise TypeError("Slot must be callable")
 
         is_coroutine = asyncio.iscoroutinefunction(slot)
         conn_type = (
-            TConnectionType.QueuedConnection
+            TConnectionType.QUEUED_CONNECTION
             if is_coroutine
-            else TConnectionType.DirectConnection
+            else TConnectionType.DIRECT_CONNECTION
         )
         self.connections.append((receiver, slot, conn_type))
 
@@ -114,18 +125,18 @@ def disconnect(self, receiver: object = None, slot: Callable = None) -> int:
 
         self.connections = new_connections
         disconnected = original_count - len(self.connections)
-        logger.debug(f"Disconnected {disconnected} connection(s)")
+        logger.debug("Disconnected %d connection(s)", disconnected)
         return disconnected
 
     def emit(self, *args, **kwargs):
+        """Emit signal to connected slots."""
         logger.debug("Signal emission started")
 
-        current_loop = asyncio.get_event_loop()
         for receiver, slot, conn_type in self.connections:
             try:
-                if conn_type == TConnectionType.DirectConnection:
+                if conn_type == TConnectionType.DIRECT_CONNECTION:
                     slot(*args, **kwargs)
-                else:  # QueuedConnection
+                else:  # QUEUED_CONNECTION
                     receiver_loop = getattr(receiver, "_loop", None)
                     if not receiver_loop:
                         logger.error("No event loop found for receiver")
@@ -171,6 +182,7 @@ 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)
 
             if not hasattr(self, _SignalConstants.THREAD):
@@ -198,6 +210,7 @@ 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)
 
             if not hasattr(self, _SignalConstants.THREAD):
@@ -215,7 +228,7 @@ def wrapper(self, *args, **kwargs):
                 if current_thread != self._thread:
                     logger.debug("Executing regular slot from different thread")
                     self._loop.call_soon_threadsafe(lambda: func(self, *args, **kwargs))
-                    return
+                    return None
 
             return func(self, *args, **kwargs)
 

tests/conftest.py

@@ -1,71 +1,88 @@
-import pytest
+"""
+Shared fixtures for tests.
+"""
+
+# pylint: disable=no-member
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-variable
+# pylint: disable=unused-argument
+# pylint: disable=property-with-parameters
+
+import os
+import sys
 import asyncio
 import threading
-from tsignal import t_with_signals, t_signal, t_slot
 import logging
-import sys
-import os
+import pytest
+from tsignal import t_with_signals, t_signal, t_slot
 
 # Only creating the logger without configuration
 logger = logging.getLogger(__name__)
 
 
 @pytest.fixture(scope="function")
 def event_loop():
+    """Create an event loop"""
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     yield loop
     loop.close()
 
-
 @t_with_signals
 class Sender:
+    """Sender class"""
     @t_signal
     def value_changed(self, value):
         """Signal for value changes"""
-        pass
 
     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
         self.received_count = 0
         self.id = id(self)
-        logger.info(f"Created Receiver[{self.id}]")
+        logger.info("Created Receiver[%d]", self.id)
 
     @t_slot
     async def on_value_changed(self, value: int):
-        logger.info(f"Receiver[{self.id}] on_value_changed called with value: {value}")
-        logger.info(f"Current thread: {threading.current_thread().name}")
-        logger.info(f"Current event loop: {asyncio.get_running_loop()}")
+        """Slot for value changes"""
+        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(
-            f"Receiver[{self.id}] updated: value={self.received_value}, count={self.received_count}"
+            "Receiver[%d] updated: value=%d, count=%d",
+            self.id, self.received_value, self.received_count
         )
 
     @t_slot
     def on_value_changed_sync(self, value: int):
-        print(f"Receiver[{self.id}] received value (sync): {value}")
+        """Sync slot for value changes"""
+        logger.info("Receiver[%d] on_value_changed_sync called with value: %d", self.id, value)
         self.received_value = value
         self.received_count += 1
-        print(
-            f"Receiver[{self.id}] updated (sync): value={self.received_value}, count={self.received_count}"
+        logger.info(
+            "Receiver[%d] updated (sync): value=%d, count=%d",
+            self.id, self.received_value, self.received_count
         )
 
 
 @pytest.fixture
 def receiver(event_loop):
+    """Create a receiver"""
     return Receiver()
 
 
 @pytest.fixture
 def sender(event_loop):
+    """Create a sender"""
     return Sender()
 
 
@@ -80,9 +97,8 @@ def setup_logging():
 
     # Can enable DEBUG mode via environment variable
 
-    default_level = logging.DEBUG
-    # if os.environ.get("TSIGNAL_DEBUG"):
-    #    default_level = logging.DEBUG
+    if os.environ.get("TSIGNAL_DEBUG"):
+        default_level = logging.DEBUG
 
     root.setLevel(default_level)