feat: Add worker thread pattern and enhance signal connections

This commit introduces several major enhancements:

1. Worker Thread Pattern
- Add @t_with_worker decorator for background thread management
- Implement task queue with async support
- Add graceful initialization/cleanup lifecycle
- Add comprehensive worker thread tests

2. Signal Connection Enhancement
- Support direct function/lambda connections
- Support method connections without @t_slot
- Improve thread-safe signal emission
- Clean up debug logging

3. Documentation
- Add worker pattern documentation and examples
- Update API reference for new connection types
- Add Windows-specific IOCP termination notes
- Reorganize examples for better clarity

4. Example Reorganization
- Rename examples for consistency
- Add worker thread pattern example
- Update thread communication examples

Test Coverage: 100%
Breaking Changes: None

Author: san-tekart

CHANGELOG.md

@@ -14,3 +14,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Automatic connection type detection
 - Comprehensive test suite
 - Full documentation
+
+## [0.1.1] - 2024-12-01
+
+### Changed
+- Refactored signal connection logic to support direct function connections.
+- Improved error handling for invalid connections.
+- Enhanced logging for signal emissions and connections.
+
+### Fixed
+- Resolved issues with disconnecting slots during signal emissions.
+- Fixed bugs related to async slot processing and connection management.
+
+### Removed
+- Deprecated unused constants and methods from the core module.

README.md

@@ -132,3 +132,88 @@ Please see [Contributing Guidelines](CONTRIBUTING.md) for details on how to cont
 
 ## License
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Connecting Signals and Slots
+
+### Classic Object-Member Connection
+```python
+@t_with_signals
+class Counter:
+    @t_signal
+    def count_changed(self):
+        pass
+
+@t_with_signals
+class Display:
+    @t_slot
+    def on_count_changed(self, value):
+        print(f"Count is now: {value}")
+
+counter = Counter()
+display = Display()
+counter.count_changed.connect(display, display.on_count_changed)
+```
+
+### Function Connection
+```python
+# Connect to a simple function
+def print_value(value):
+    print(f"Value: {value}")
+    
+counter.count_changed.connect(print_value)
+
+# Connect to a lambda
+counter.count_changed.connect(lambda x: print(f"Lambda received: {x}"))
+
+# Connect to an object method without @t_slot
+class Handler:
+    def process_value(self, value):
+        print(f"Processing: {value}")
+        
+handler = Handler()
+counter.count_changed.connect(handler.process_value)
+```
+
+## Worker Thread Pattern
+
+TSignal provides a worker thread pattern that combines thread management with signal/slot communication and task queuing:
+
+```python
+from tsignal import t_with_worker
+
+@t_with_worker
+class DataProcessor:
+    async def initialize(self, config=None):
+        # Setup worker (called in worker thread)
+        self.config = config or {}
+    
+    async def process_data(self, data):
+        # Heavy processing in worker thread
+        result = await heavy_computation(data)
+        self.processing_done.emit(result)
+    
+    async def finalize(self):
+        # Cleanup worker (called before thread stops)
+        await self.cleanup()
+
+    @t_signal
+    def processing_done(self):
+        pass
+
+# Usage
+processor = DataProcessor()
+processor.start(config={'threads': 4})  # Starts worker thread
+
+# Queue task in worker thread
+await processor.queue_task(processor.process_data(some_data))
+
+# Stop worker
+processor.stop()  # Graceful shutdown
+```
+
+The worker pattern provides:
+- Dedicated worker thread with event loop
+- Built-in signal/slot support
+- Async task queue
+- Graceful initialization/shutdown
+- Thread-safe communication

docs/api.md

@@ -36,20 +36,61 @@ async def on_async_signal(self, *args, **kwargs):
     pass
 ```
 
+### `@t_with_worker`
+Class decorator that creates a worker thread with signal support and task queue.
+
+**Requirements:**
+- Class must implement async `initialize(self, *args, **kwargs)` method
+- Class must implement async `finalize(self)` method
+
+**Added Methods:**
+##### `start(*args, **kwargs) -> None`
+Starts the worker thread and calls initialize with given arguments.
+
+##### `stop() -> None`
+Stops the worker thread gracefully, calling finalize.
+
+##### `async queue_task(coro) -> None`
+Queues a coroutine for execution in the worker thread.
+
+**Example:**
+```python
+@t_with_worker
+class Worker:
+    async def initialize(self):
+        print("Worker initialized")
+    
+    async def finalize(self):
+        print("Worker cleanup")
+    
+    async def process(self):
+        await asyncio.sleep(1)
+        print("Processing done")
+
+worker = Worker()
+worker.start()
+await worker.queue_task(worker.process())
+worker.stop()
+```
+
 ## Classes
 
 ### `TSignal`
 Base class for signals.
 
 #### Methods
 
-##### `connect(receiver: object, slot: Callable, connection_type: Optional[TConnectionType] = None) -> None`
+##### `connect(receiver_or_slot: Union[object, Callable], slot: Optional[Callable] = None) -> None`
 Connects the signal to a slot.
 
 **Parameters:**
-- `receiver`: Object that contains the slot
-- `slot`: Callable that will receive the signal
-- `connection_type`: Optional connection type (DirectConnection or QueuedConnection)
+- When connecting to a QObject slot:
+  - `receiver_or_slot`: The receiver object
+  - `slot`: The slot method of the receiver
+
+- When connecting to a function/lambda:
+  - `receiver_or_slot`: The callable (function, lambda, or method)
+  - `slot`: None
 
 ##### `disconnect(receiver: Optional[object] = None, slot: Optional[Callable] = None) -> int`
 Disconnects one or more slots from the signal.
@@ -107,16 +148,6 @@ Enum defining connection types.
 - `DirectConnection`: Slot is called directly in the emitting thread
 - `QueuedConnection`: Slot is queued in the receiver's event loop
 
-## Constants
-
-### `TSignalConstants`
-Constants used by the TSignal system.
-
-#### Values:
-- `FROM_EMIT`: Key for emission context
-- `THREAD`: Key for thread storage
-- `LOOP`: Key for event loop storage
-
 ## Usage Examples
 
 ### Basic Signal-Slot

docs/usage.md

@@ -7,6 +7,7 @@
 4. [Connection Types](#connection-types)
 5. [Threading and Async](#threading-and-async)
 6. [Best Practices](#best-practices)
+7. [Worker Thread Pattern](#worker-thread-pattern)
 
 ## Basic Concepts
 TSignal implements the signal-slot pattern, which allows for loose coupling between components. The core concepts are:
@@ -277,3 +278,140 @@ This understanding of signal disconnection behavior is crucial for:
 - Ensuring proper resource cleanup
 - Managing complex async operations
 - Handling thread synchronization correctly
+
+## Signal Connection Types
+
+### Object-Member Connection
+Traditional signal-slot connection between objects:
+```python
+@t_with_signals
+class Sender:
+    @t_signal
+    def value_changed(self):
+        pass
+
+@t_with_signals
+class Receiver:
+    @t_slot
+    def on_value_changed(self, value):
+        print(f"Value: {value}")
+
+sender.value_changed.connect(receiver, receiver.on_value_changed)
+```
+
+### Function Connection
+Connect signals directly to functions or lambdas:
+```python
+# Standalone function
+def handle_value(value):
+    print(f"Value: {value}")
+sender.value_changed.connect(handle_value)
+
+# Lambda function
+sender.value_changed.connect(lambda x: print(f"Value: {x}"))
+```
+
+### Method Connection
+Connect to object methods without @t_slot decorator:
+```python
+class Handler:
+    def process(self, value):
+        print(f"Processing: {value}")
+
+handler = Handler()
+sender.value_changed.connect(handler.process)
+```
+
+### Connection Behavior Notes
+- Object-member connections are automatically disconnected when the receiver is destroyed
+- Function connections remain active until explicitly disconnected
+- Method connections behave like function connections and need manual cleanup
+
+## Worker Thread Pattern
+
+### Overview
+The worker pattern provides a convenient way to run operations in a background thread with built-in signal/slot support and task queuing.
+
+### Basic Worker
+```python
+@t_with_worker
+class ImageProcessor:
+    async def initialize(self, cache_size=100):
+        """Called when worker starts"""
+        self.cache = {}
+        self.cache_size = cache_size
+    
+    async def finalize(self):
+        """Called before worker stops"""
+        self.cache.clear()
+    
+    @t_signal
+    def processing_complete(self):
+        """Signal emitted when processing is done"""
+        pass
+    
+    async def process_image(self, image_data):
+        """Task to be executed in worker thread"""
+        result = await self.heavy_processing(image_data)
+        self.processing_complete.emit(result)
+
+# Usage
+processor = ImageProcessor()
+processor.start(cache_size=200)
+
+# Queue tasks
+await processor.queue_task(processor.process_image(data1))
+await processor.queue_task(processor.process_image(data2))
+
+# Cleanup
+processor.stop()
+```
+
+### Worker Features
+
+#### Thread Safety
+- All signal emissions are thread-safe
+- Task queue is thread-safe
+- Worker has its own event loop
+
+#### Task Queue
+- Tasks are executed sequentially
+- Tasks must be coroutines
+- Queue is processed in worker thread
+
+#### Lifecycle Management
+```python
+@t_with_worker
+class Worker:
+    async def initialize(self, *args, **kwargs):
+        # Setup code
+        self.resources = await setup_resources()
+    
+    async def finalize(self):
+        # Cleanup code
+        await self.resources.cleanup()
+    
+    async def some_task(self):
+        # Will run in worker thread
+        await self.resources.process()
+
+worker = Worker()
+try:
+    worker.start()
+    await worker.queue_task(worker.some_task())
+finally:
+    worker.stop()  # Ensures cleanup
+```
+
+#### Combining with Signals
+Workers can use signals to communicate results:
+```python
+@t_with_worker
+class DataProcessor:
+    def __init__(self):
+        super().__init__()
+        self.results = []
+    
+    @t_signal
+    def processing_done(self):
+        """Emitted when batch is