curious.core.event

Special helpers for events.

Functions

event(name[, scan])	Marks a function as an event.
scan_events(obb)	Scans an object for any items marked as an event and yields them.

Classes

EventContext(cl, shard_id, event_name)	Represents a special context that are passed to events.
EventManager()	A manager for events.

Exceptions

ListenerExit

Raised when a temporary listener is to be exited.

exception curious.core.event.ListenerExit

Bases: Exception

Raised when a temporary listener is to be exited.

def listener(ctx, message):
    if message.author.id == message.guild.owner_id:
        raise ListenerExit

with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

async with curious.core.event._wait_for_manager(manager, name, predicate)

Helper class for managing a wait_for.

class curious.core.event.EventManager

Bases: object

A manager for events.

This deals with firing of events and temporary listeners.

task_manager = None

The task manager used to spawn events.

event_hooks = None

A list of event hooks.

event_listeners = None

A MultiDict of event listeners.

temporary_listeners = None

A MultiDict of temporary listeners.

add_event(func, name=None)

Add an event to the internal registry of events.

Parameters:

• name (Optional[str]) – The event name to register under.
• func – The function to add.

remove_event(name, func)

Removes a function event.

Parameters:

• name (str) – The name the event is registered under.
• func – The function to remove.

add_temporary_listener(name, listener)

Adds a new temporary listener.

To remove the listener, you can raise ListenerExit which will exit it and remove the listener from the list.

Parameters:

• name (str) – The name of the event to listen to.
• listener – The listener function.

remove_listener_early(name, listener)

Removes a temporary listener early.

Parameters:

• name (str) – The name of the event the listener is registered under.
• listener – The listener function.

add_event_hook(listener)

Adds an event hook.

Parameters:listener – The event hook callable to use.

remove_event_hook(listener)

Removes an event hook.

await _safety_wrapper(func, *args, **kwargs)

Ensures a coro’s error is caught and doesn’t balloon out.

await _listener_wrapper(key, func, *args, **kwargs)

Wraps a listener, ensuring ListenerExit is handled properly.

await wait_for(event_name, predicate=None)

Waits for an event.

Returning a truthy value from the predicate will cause it to exit and return.

Parameters:

• event_name (str) – The name of the event.
• predicate – The predicate to use to check for the event.

wait_for_manager(event_name, predicate)

Returns a context manager that can be used to run some steps whilst waiting for a temporary listener.

async with client.events.wait_for_manager("member_update", predicate=...):
    await member.nickname.set("Test")

This probably won’t be needed outside of internal library functions.

Return type:AsyncContextManager[None]

await spawn(cofunc, *args)

Spawns a new async function using our task manager.

Usage:

async def myfn(a, b):
    await do_some_operation(a + b)

await events.spawn(myfn, 1, 2)

Parameters:

• cofunc – The async function to spawn.
• args – Args to provide to the async function.

Return type:

Any

await fire_event(event_name, *args, **kwargs)

Fires an event.

Parameters:event_name (str) – The name of the event to fire.

curious.core.event.event(name, scan=True)

Marks a function as an event.

Parameters:

• name – The name of the event.
• scan (bool) – Should this event be handled in scans too?

for ... in curious.core.event.scan_events(obb)

Scans an object for any items marked as an event and yields them.

Return type:Generator[None, Tuple[str, Any], None]

class curious.core.event.EventContext(cl: curious.core.client.Client, shard_id: int, event_name: str)

Bases: object

Represents a special context that are passed to events.

Parameters:

• cl (Client) – The Client instance for this event context.
• shard_id (int) – The shard ID this event is for.
• event_name (str) – The event name for this event.

bot = None

The Client instance that this event was fired under.

shard_id = None

The shard this event was received on.

shard_count = None

The shard for this bot.

event_name = None

The event name for this event.

handlers

Return type:List[Callable[[EventContext], None]] Returns:A list of handlers registered for this event.

await change_status(*args, **kwargs)

Changes the current status for this shard.

This takes the same arguments as Client.change_status, but ignoring the shard ID.

Return type:None

gateway

Return type:GatewayHandler Returns:The Gateway that produced this event.