Event Handlers

def on(
    type: str = "",
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create a basic event responder.

    Parameters:
    - type: Event type to match
    - rule: Rule for matching events
    - permission: Permission for handling events
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for this event handler
    """

import nonebot
from nonebot import on
from nonebot.adapters import Bot, Event

# Create a handler for any event
any_event = on()

@any_event.handle()
async def handle_any_event(bot: Bot, event: Event):
    print(f"Received event: {event.get_type()}")

# Create a handler with specific rule
from nonebot.rule import keyword

keyword_handler = on(rule=keyword("help"))

@keyword_handler.handle() 
async def handle_help(bot: Bot, event: Event):
    await bot.send(event, "This is help information")

def on_message(
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create a message event handler.

    Parameters:
    - rule: Rule for matching messages
    - permission: Permission for handling messages
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for message events
    """

import nonebot
from nonebot import on_message
from nonebot.adapters import Bot, Event

# Handle all messages
message_handler = on_message()

@message_handler.handle()
async def handle_message(bot: Bot, event: Event):
    message_text = event.get_plaintext()
    await bot.send(event, f"You said: {message_text}")

# Handle messages with specific permission
from nonebot.permission import SUPERUSER

admin_messages = on_message(permission=SUPERUSER)

@admin_messages.handle()
async def handle_admin_message(bot: Bot, event: Event):
    await bot.send(event, "Admin command received")

def on_notice(
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create a notice event handler.

    Parameters:
    - rule: Rule for matching notices
    - permission: Permission for handling notices  
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for notice events
    """

import nonebot
from nonebot import on_notice
from nonebot.adapters import Bot, Event

# Handle all notices
notice_handler = on_notice()

@notice_handler.handle()
async def handle_notice(bot: Bot, event: Event):
    notice_type = event.get_event_name()
    print(f"Notice received: {notice_type}")

# Handle with priority
priority_notice = on_notice(priority=5)

@priority_notice.handle()
async def handle_priority_notice(bot: Bot, event: Event):
    await bot.send(event, "High priority notice handler")

def on_request(
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create a request event handler.

    Parameters:
    - rule: Rule for matching requests
    - permission: Permission for handling requests
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for request events
    """

import nonebot
from nonebot import on_request
from nonebot.adapters import Bot, Event

# Handle all requests
request_handler = on_request()

@request_handler.handle()
async def handle_request(bot: Bot, event: Event):
    request_type = event.get_event_name()
    user_id = event.get_user_id()
    print(f"Request from {user_id}: {request_type}")

def on_metaevent(
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create a meta event handler.

    Parameters:
    - rule: Rule for matching meta events
    - permission: Permission for handling meta events
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for meta events
    """

import nonebot
from nonebot import on_metaevent
from nonebot.adapters import Bot, Event

# Handle meta events
meta_handler = on_metaevent()

@meta_handler.handle()
async def handle_meta(bot: Bot, event: Event):
    meta_type = event.get_event_name()
    print(f"Meta event: {meta_type}")

# Handle heartbeat specifically
from nonebot.rule import is_type

heartbeat = on_metaevent(rule=is_type("heartbeat"))

@heartbeat.handle()
async def handle_heartbeat(bot: Bot, event: Event):
    print("Bot heartbeat received")

def on_type(
    types: Union[type[Event], tuple[type[Event], ...]],
    rule: Optional[Rule] = None,
    permission: Optional[Permission] = None,
    handlers: Optional[list[_Handler]] = None,
    temp: bool = False,
    expire_time: Optional[Union[datetime, timedelta]] = None,
    priority: int = 1,
    block: bool = False,
    state: Optional[T_State] = None
) -> type[Matcher]:
    """
    Create handler for specific event types.

    Parameters:
    - types: Event type class or tuple of event type classes
    - rule: Additional rule for matching events
    - permission: Permission for handling events
    - handlers: List of handler functions
    - temp: Whether this is a temporary matcher
    - expire_time: When temporary matcher expires
    - priority: Handler priority (lower = higher priority)
    - block: Whether to block further handler execution
    - state: Initial state data

    Returns:
    type[Matcher]: Matcher class for specific event types
    """

import nonebot
from nonebot import on_type
from nonebot.adapters import Bot, Event
from nonebot.adapters.console import MessageEvent as ConsoleMessageEvent

# Handle specific event type
console_messages = on_type(ConsoleMessageEvent)

@console_messages.handle()
async def handle_console_message(bot: Bot, event: ConsoleMessageEvent):
    print(f"Console message: {event.get_plaintext()}")

# Handle multiple event types
from nonebot.adapters.console import NoticeEvent as ConsoleNoticeEvent

multi_type_handler = on_type((ConsoleMessageEvent, ConsoleNoticeEvent))

@multi_type_handler.handle()
async def handle_multiple_types(bot: Bot, event: Event):
    if isinstance(event, ConsoleMessageEvent):
        await bot.send(event, "Received console message")
    elif isinstance(event, ConsoleNoticeEvent):
        print("Received console notice")

T_State = dict[Any, Any]
T_Handler = _DependentCallable[Any]

class Matcher:
    """Event matcher class for handling events."""
    
    def handle(self) -> Callable[[T_Handler], T_Handler]:
        """Register primary handler."""
    
    def got(self, key: str, prompt: Optional[Union[str, Message, MessageSegment, MessageTemplate]] = None) -> Callable[[T_Handler], T_Handler]:
        """Register handler for getting argument."""
    
    def send(self, message: Union[str, Message, MessageSegment, MessageTemplate]) -> Callable[[T_Handler], T_Handler]:
        """Send message and continue."""
    
    def pause(self, prompt: Optional[Union[str, Message, MessageSegment, MessageTemplate]] = None) -> Callable[[T_Handler], T_Handler]:
        """Pause execution and wait for next message."""
    
    def reject(self, prompt: Optional[Union[str, Message, MessageSegment, MessageTemplate]] = None) -> Callable[[T_Handler], T_Handler]:
        """Reject current input and retry."""
    
    def finish(self, message: Optional[Union[str, Message, MessageSegment, MessageTemplate]] = None) -> Callable[[T_Handler], T_Handler]:
        """Send message and finish execution."""

class Permission:
    """Permission checker for handlers."""

class User:
    """User-based permission checker."""

class Rule:
    """Rule for matching events."""