pyee.base.EventEmitter Class Reference

Inheritance diagram for pyee.base.EventEmitter:

Public Member Functions
None	__init__ (Self self)
Mapping[str, Any]	__getstate__ (Self self)
None	__setstate__ (Self self, Mapping[str, Any] state)
Callable[[Handler], Handler]	on (Self self, str event)
Handler	on (Self self, str event, Handler f)
Union[Handler, Callable[[Handler], Handler]]	on (Self self, str event, Optional[Handler] f=None)
Callable[[Handler], Handler]	listens_to (Self self, str event)
Handler	add_listener (Self self, str event, Handler f)
Set[str]	event_names (Self self)
bool	emit (Self self, str event, *Any args, **Any kwargs)
Callable	once (Self self, str event, Optional[Callable] f=None)
None	remove_listener (Self self, str event, Callable f)
None	remove_all_listeners (Self self, Optional[str] event=None)
List[Callable]	listeners (Self self, str event)

Protected Member Functions
	_add_event_handler (Self self, str event, Callable k, Callable v)
None	_emit_run (Self self, Callable f, Tuple[Any,...] args, Dict[str, Any] kwargs)
None	_emit_handle_potential_error (Self self, str event, Any error)
bool	_call_handlers (Self self, str event, Tuple[Any,...] args, Dict[str, Any] kwargs)
None	_remove_listener (Self self, str event, Callable f)

Protected Attributes
	_lock
	_events

Detailed Description

The base event emitter class. All other event emitters inherit from
this class.

Most events are registered with an emitter via the `on` and `once`
methods, and fired with the `emit` method. However, pyee event emitters
have two *special* events:

- `new_listener`: Fires whenever a new listener is created. Listeners for
  this event do not fire upon their own creation.

- `error`: When emitted raises an Exception by default, behavior can be
  overridden by attaching callback to the event.

  For example:

```py
@ee.on('error')
def on_error(message):
    logging.err(message)

ee.emit('error', Exception('something blew up'))
```

All callbacks are handled in a synchronous, blocking manner. As in node.js,
raised exceptions are not automatically handled for you---you must catch
your own exceptions, and treat them accordingly.

Member Function Documentation

_remove_listener()

None pyee.base.EventEmitter._remove_listener ( Self  self, str  event, Callable  f  )

protected

Naked unprotected removal.

add_listener()

Handler pyee.base.EventEmitter.add_listener	(	Self	self,
		str	event,
		Handler	f
	)

Register the function `f` to the event name `event`:

```
def data_handler(data):
    print(data)

h = ee.add_listener("event", data_handler)
```

By not supporting the decorator use case, this method has improved
type safety over `EventEmitter#on`.

emit()

bool pyee.base.EventEmitter.emit	(	Self	self,
		str	event,
		*Any	args,
		**Any	kwargs
	)

Emit `event`, passing `*args` and `**kwargs` to each attached
function. Returns `True` if any functions are attached to `event`;
otherwise returns `False`.

Example:

```py
ee.emit('data', '00101001')
```

Assuming `data` is an attached function, this will call
`data('00101001')'`.

Reimplemented in pyee.asyncio.AsyncIOEventEmitter.

event_names()

Set[str] pyee.base.EventEmitter.event_names

(

Self

self

)

Get a set of events that this emitter is listening to.

listeners()

List[Callable] pyee.base.EventEmitter.listeners	(	Self	self,
		str	event
	)

Returns a list of all listeners registered to the `event`.

listens_to()

Callable[[Handler], Handler] pyee.base.EventEmitter.listens_to	(	Self	self,
		str	event
	)

Returns a decorator which will register the decorated function to
the event name `event`:

```py
@ee.listens_to("event")
def data_handler(data):
    print(data)
```

By only supporting the decorator use case, this method has improved
type safety over `EventEmitter#on`.

on()

Union[Handler, Callable[[Handler], Handler]] pyee.base.EventEmitter.on	(	Self	self,
		str	event,
		Optional[Handler]	f = None
	)

Registers the function `f` to the event name `event`, if provided.

If `f` isn't provided, this method calls `EventEmitter#listens_to`, and
otherwise calls `EventEmitter#add_listener`. In other words, you may either
use it as a decorator:

```py
@ee.on('data')
def data_handler(data):
    print(data)
```

Or directly:

```py
ee.on('data', data_handler)
```

In both the decorated and undecorated forms, the event handler is
returned. The upshot of this is that you can call decorated handlers
directly, as well as use them in remove_listener calls.

Note that this method's return type is a union type. If you are using
mypy or pyright, you will probably want to use either
`EventEmitter#listens_to` or `EventEmitter#add_listener`.

once()

Callable pyee.base.EventEmitter.once	(	Self	self,
		str	event,
		Optional[Callable]	f = None
	)

The same as `ee.on`, except that the listener is automatically
removed after being called.

remove_all_listeners()

None pyee.base.EventEmitter.remove_all_listeners	(	Self	self,
		Optional[str]	event = None
	)

Remove all listeners attached to `event`.
If `event` is `None`, remove all listeners on all events.

remove_listener()

None pyee.base.EventEmitter.remove_listener	(	Self	self,
		str	event,
		Callable	f
	)

Removes the function `f` from `event`.

Reimplemented in playwright._impl._connection.ChannelOwner.

---

The documentation for this class was generated from the following file:

• docs/help/help-venv/lib/python3.12/site-packages/pyee/base.py