Are you looking for a signal/slotpattern in Python without Qt dependencies? TSignalprovidesa lightweight,thread-safe,andasyncio-compatibleimplementation that gives you allthepower of Qt's signal/slot pattern without the heavyweight dependencies.Perfect for:

TSignal is a lightweight, pure-Python signal/slotlibrary thatprovides thread-safe, asyncio-compatibleevent handling inspired bytheQt signal/slot pattern—but without the heavyweightQtdependencies.It enables clean decoupling of components, seamless thread-to-thread communication, and flexible asynchronous/synchronous slot handling.

- Async applications needing event handling

- Thread communication in Python applications

- Event-driven architectures

- Decoupled component communication

-**Pure Python**: No Qt or external GUI frameworks needed.

-**Async/Await Friendly**: Slots can be synchronous or asynchronous, and integrate seamlessly with asyncio.

-**Thread-Safe**: Signal emissions and slot executions are automatically managed for thread safety.

-**Flexible Connection Types**: Direct or queued connections, automatically chosen based on the caller and callee threads.

-**Worker Thread Pattern**: Simplify background task execution with a built-in worker pattern that provides an event loop and task queue in a dedicated thread.

-**Familiar Decorators**: Inspired by Qt’s pattern,`@t_with_signals`,`@t_signal`, and`@t_slot` let you define signals and slots declaratively.

- 🚀 Pure Python implementation - no Qt or external dependencies required

- ⚡ Async/await support out of the box

- 🔒 Thread-safe signal emission and slot execution

- 🎯 Simple, decorator-based API similar to Qt

- 🔄 Automatic thread handling for cross-thread signals

Modern Python applications often rely on asynchronous operations and multi-threading. Traditional event frameworks either require large external dependencies or lack seamless async/thread support. TSignal provides:

- A minimal, dependency-free solution for event-driven architectures.

- Smooth integration with asyncio for modern async Python code.

- Automatic thread-affinity handling so cross-thread signals "just work."

- Decorator-based API that’s intuitive and maintainable.

TSignal requires Python 3.10 or higher.

git clone https://github.com/TSignalDev/tsignal-python.git

cd tsignal-python

pip install -e.

For development (includes tests and linting tools):

counter.increment()# Will print: "Count is now: 1"

classAsyncDisplay:

asyncio.run(main())

- Requires Python 3.10+

- Easy-to-use signal-slot mechanism with decorators

- Support for both synchronous and asynchronous slots

- Thread-safe signal emissions

- Automatic connection type detection (direct/queued)

- Compatible with Python's asyncio

- Signals: Declared with`@t_signal`. Signals are attributes of a class that can be emitted to notify interested parties.

- Slots: Declared with`@t_slot`. Slots are methods that respond to signals. Slots can be synchronous or async functions.

- Connections: Use`signal.connect(receiver, slot)` to link signals to slots. Connections can also be made directly to functions or lambdas.

TSignal requires Python 3.10 or higher. You can install it directly from the repository:

TSignal automatically detects whether the signal emission and slot execution occur in the same thread or different threads:

git clone https://github.com/tsignal/tsignal-python.git

cd tsignal-python

pip install -e.

-**Direct Connection**: If signal and slot share the same thread affinity, the slot is invoked directly.

-**Queued Connection**: If they differ, the call is queued to the slot’s thread/event loop, ensuring thread safety.

For development installation (includes test dependencies):

pip install -e".[dev]"

This mechanism frees you from manually dispatching calls across threads.

-[Detailed Usage Guide](docs/usage.md)

-[API Reference](docs/api.md)

-[Examples](docs/examples.md)

-[Logging Guidelines](docs/logging.md)

-[Testing Guide](docs/testing.md)

For background work, TSignal provides a`@t_with_worker` decorator that:

- Spawns a dedicated event loop in a worker thread.

- Allows you to queue async tasks to this worker.

- Enables easy start/stop lifecycle management.

- Integrates with signals and slots for thread-safe updates to the main

TSignal uses Python's standard logging module. For detailed logging configuration,

please see[Logging Guidelines](docs/logging.md).

**Worker Example**

from tsignalimport t_with_worker, t_signal

classDataProcessor:

defprocessing_done(self):

asyncdefrun(self,*args,**kwargs):

awaitself._tsignal_stopping.wait()

asyncdefprocess_data(self,data):

result=await heavy_computation(data)

self.processing_done.emit(result)

processor= DataProcessor()

processor.start()

processor.queue_task(processor.process_data(some_data))

processor.stop()

-[Usage Guide](docs/usage.md): Learn how to define signals/slots, manage threads, and structure your event-driven code.

-[API Reference](docs/api.md): Detailed documentation of classes, decorators, and functions.

-[Examples](docs/examples.md): Practical use cases, including UI integration, async operations, and worker pattern usage.

-[Logging Guidelines](docs/logging.md): Configure logging levels and handlers for debugging.

-[Testing Guide](docs/testing.md): earn how to run tests and contribute safely.

Configure logging to diagnose issues:

Basic usage:

import logging

logging.getLogger('tsignal').setLevel(logging.INFO)

logging.getLogger('tsignal').setLevel(logging.DEBUG)

For more details, see the[Logging Guidelines](docs/logging.md).

TSignalincludes a comprehensive test suite usingpytest. For basic testing:

TSignaluses`pytest` for testing:

pytest tests/unit/test_signal.py

For detailed testing instructions and guidelines, see[Testing Guide](docs/testing.md).

See the[Testing Guide](docs/testing.md) for more details.

Pleasesee[Contributing Guidelines](CONTRIBUTING.md)for details on how to contribute to this project.

We welcome contributions.Pleaseread the[Contributing Guidelines](CONTRIBUTING.md)before submitting PRs.

This project is licensed under the MIT License - see the[LICENSE](LICENSE) file for details.

classCounter:

defcount_changed(self):

classDisplay:

defon_count_changed(self,value):

print(f"Count is now:{value}")

counter= Counter()

display= Display()

counter.count_changed.connect(display, display.on_count_changed)

defprint_value(value):

print(f"Value:{value}")

counter.count_changed.connect(print_value)

counter.count_changed.connect(lambdax:print(f"Lambda received:{x}"))

classHandler:

defprocess_value(self,value):

print(f"Processing:{value}")

handler= Handler()

counter.count_changed.connect(handler.process_value)

TSignal provides a worker thread pattern that combines thread management with signal/slot communication and task queuing:

from tsignalimport t_with_worker

classDataProcessor:

asyncdefinitialize(self,config=None):

self.config= configor {}

asyncdefprocess_data(self,data):

result=await heavy_computation(data)

self.processing_done.emit(result)

asyncdeffinalize(self):

awaitself.cleanup()

defprocessing_done(self):

processor= DataProcessor()

processor.start(config={'threads':4})# Starts worker thread

await processor.queue_task(processor.process_data(some_data))

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

TSignal is licensed under the MIT License. See[LICENSE](LICENSE) for details.