Examples

Here a few examples to use this library functionality and type hints.

Simple overview to instance the connectable objects and connect them a function.

from emitcallback import Single, Signal, Queue

# example method we want to connect.
def callback():
	print("Hello World!")

# create a single and connect the callback.
single = Single()
single.connect(callback)

# create a signal and connect the callback.
signal = Signal()
signal.connect(callback)

# create a queue and connect the callback.
queue = Queue()
queue.connect(callback)

Connects twince the function using mutiple flags at once.

from emitcallback import Signal, SINGLE_ONE_SHOT, SIGNAL_MULTI_CONNECT

def callback():
	print("Hello World!")

s = Signal()

# allows the function to be connected more than once and that on the next emittion will be disconnected.
s.connect(callback, flags = SINGLE_ONE_SHOT|SIGNAL_MULTI_CONNECT)
s.connect(callback, flags = SIGNAL_MULTI_CONNECT)

# calls both function.
s.emit()
# calls only the one that wasn't connected with oneshot.
s.emit()

# This on the first emittion.
> "Hello World"
> "Hello World"

# This on the second emittiong, the first connection has been removed by oneshot.
> "Hello World"

Shows how each kind of callables can be connected.

from emitcallback import Signal

def function():
	print("Hello Function!")

class Class:

	def method(self):
		print("Hello Class!")

obj = Class()

# any connections happens the same way!
s = Signal()
s.connect(lambda: print("Hello Lambda!"))
s.connect(function)
s.connect(obj.method)

s.emit()

Shows how a method weak connection works when the garbage collector destroy the object.

from emitcallback import Signal

class Class:

	def method(self):
		print("Hello Class!")

# here object is created.
obj = Class()

# here method (using weak reference is connected) is connected.
s = Signal()
s.connect(obj.method)

# garbage collector destroy the object because there are no more references of it.
# emittion won't call method because it got disconnected here.
del obj

s.emit()

Shows how a method strong connection can be created.

from emitcallback import Signal, SIGNAL_NO_WEAK

class Class:

	def method(self):
		print("Hello Class!")

# here object is created.
obj = Class()

# here method (using weak reference is connected) is connected.
s = Signal()
s.connect(obj.method, flags = SIGNAL_NO_WEAK)

# garbage collector reduces reference but object has still one left from the signal.
del obj

# calls the method. here the obj variable is no longer avaiable but object still exist.
s.emit()

Note

Functions and lambdas always use a strong connection, weak connections are only for methods.

Shows how to create a signal and function with type hints.

from emitcallback import Signal, Single, Queue

def callback(value: int) -> None:
	print(f"Value is {value} !")

# put list of argouments type you expect separated by commas.
s1 = Signal[int]()

# type hints will show a warning if the callback doesn't match his signature
# or if emit doesn't have all argouments.
s1.connect(callback)
s1.emit(10)

> "Value is 10!"

More showcase of type hints.

from emitcallback import Signal, Single, Queue

# other combinations of type hints:
Signal[int]()
Signal[str, int]()
Signal[int, str, bool]()
Signal[list[int], bool]()

Single[int]()
Single[str, int]()
Single[int, str, bool]()
Single[list[int], bool]()

Queue[int]()
Queue[str, int]()
Queue[int, str, bool]()
Queue[list[int], bool]()

# using it with variables:
s1 = Signal[int]()

s2: Signal[int] = Signal()