Messaging System - rebootpy

Overview

rebootpy supports two types of messages:

Friend Messages - Direct messages between friends
Party Messages - Messages in party chat

Both message types share similar functionality but have different contexts.

Message Classes

FriendMessage

Represents a message from a friend. Attributes:

client - The client instance
author - The Friend who sent the message
content - The message text (up to 256 characters)
created_at - When the message was received (UTC datetime)

PartyMessage

Represents a message in party chat. Attributes:

client - The client instance
author - The PartyMember who sent the message
content - The message text (up to 256 characters)
party - The ClientParty where the message was sent
created_at - When the message was received (UTC datetime)

Receiving Messages

Friend Messages

@client.event
async def event_friend_message(message):
    print(f'{message.author.display_name}: {message.content}')
    print(f'Received at: {message.created_at}')

Party Messages

@client.event
async def event_party_message(message):
    print(f'[Party] {message.author.display_name}: {message.content}')
    print(f'Party ID: {message.party.id}')

Sending Messages

Send to Friend

# Method 1: Using Friend object
friend = client.get_friend('user-id')
await friend.send('Hello!')

# Method 2: Using client.http
await client.http.friend_send_message('user-id', 'Hello!')

Send to Party

# Send message to current party
await client.party.send('Hello everyone!')

Replying to Messages

@client.event
async def event_friend_message(message):
    # Reply to friend message
    await message.reply('Thanks for your message!')

@client.event
async def event_party_message(message):
    # Reply in party chat
    if message.author.id != client.user.id:
        await message.reply(f'You said: {message.content}')

Message Length Limit

Messages are limited to 256 characters. Longer messages will raise an error:

from rebootpy.errors import ChatError

@client.event
async def event_friend_message(message):
    try:
        long_message = 'A' * 300  # Too long!
        await message.reply(long_message)
    except ChatError as e:
        print(f'Message too long: {e}')
        await message.reply('My response was too long!')

Command Patterns

Simple Command Handler

@client.event
async def event_friend_message(message):
    # Ignore messages from self
    if message.author.id == client.user.id:
        return
    
    content = message.content.lower()
    
    if content == '!hello':
        await message.reply('Hello!')
    elif content == '!stats':
        stats = await client.fetch_br_stats(message.author.id)
        await message.reply(f'Wins: {stats.total_wins}')
    elif content == '!help':
        await message.reply('Commands: !hello, !stats, !help')

Command with Arguments

@client.event
async def event_friend_message(message):
    if not message.content.startswith('!'):
        return
    
    parts = message.content.split()
    command = parts[0][1:].lower()  # Remove '!' prefix
    args = parts[1:]
    
    if command == 'user':
        if not args:
            await message.reply('Usage: !user <name>')
            return
        
        username = ' '.join(args)
        user = await client.fetch_user(username)
        
        if user:
            await message.reply(f'Found: {user.display_name} ({user.id})')
        else:
            await message.reply('User not found')
    
    elif command == 'invite':
        await client.party.invite(message.author.id)
        await message.reply('Party invite sent!')

Party Command Handler

@client.event
async def event_party_message(message):
    # Ignore own messages
    if message.author.id == client.user.id:
        return
    
    content = message.content.lower()
    
    if content == '!ready':
        await client.party.me.set_ready(rebootpy.ReadyState.READY)
        await message.reply('Ready!')
    
    elif content == '!privacy public':
        if client.party.me.leader:
            await client.party.set_privacy(rebootpy.PartyPrivacy.PUBLIC)
            await message.reply('Party is now public')
        else:
            await message.reply('I\'m not the leader!')

Conversation Flow

Ask and Wait for Response

import asyncio

@client.event
async def event_friend_message(message):
    if message.content.lower() == '!quiz':
        await message.reply('What is 2 + 2?')
        
        def check(m):
            return m.author.id == message.author.id
        
        try:
            response = await client.wait_for(
                'friend_message',
                check=check,
                timeout=30
            )
            
            if response.content == '4':
                await response.reply('Correct!')
            else:
                await response.reply('Wrong! The answer is 4')
        
        except asyncio.TimeoutError:
            await message.reply('You took too long!')

Multi-step Conversation

@client.event
async def event_friend_message(message):
    if message.content.lower() == '!setup':
        author = message.author
        
        def check(m):
            return m.author.id == author.id
        
        try:
            # Step 1: Ask for name
            await message.reply('What is your name?')
            name_msg = await client.wait_for('friend_message', check=check, timeout=60)
            name = name_msg.content
            
            # Step 2: Ask for age
            await name_msg.reply(f'Nice to meet you, {name}! How old are you?')
            age_msg = await client.wait_for('friend_message', check=check, timeout=60)
            age = age_msg.content
            
            # Done
            await age_msg.reply(f'Setup complete! Name: {name}, Age: {age}')
        
        except asyncio.TimeoutError:
            await message.reply('Setup cancelled (timeout)')

Message Filtering

Ignore Bot Messages

@client.event
async def event_friend_message(message):
    # Don't respond to own messages
    if message.author.id == client.user.id:
        return
    
    await message.reply('I got your message!')

Whitelist System

ALLOWED_USERS = ['user-id-1', 'user-id-2', 'user-id-3']

@client.event
async def event_friend_message(message):
    if message.author.id not in ALLOWED_USERS:
        return  # Ignore messages from non-whitelisted users
    
    # Process message
    await message.reply('Command received!')

Spam Protection

import time
from collections import defaultdict

message_counts = defaultdict(list)
SPAM_THRESHOLD = 5  # messages
SPAM_WINDOW = 10    # seconds

@client.event
async def event_friend_message(message):
    user_id = message.author.id
    current_time = time.time()
    
    # Clean old timestamps
    message_counts[user_id] = [
        t for t in message_counts[user_id]
        if current_time - t < SPAM_WINDOW
    ]
    
    # Check spam
    if len(message_counts[user_id]) >= SPAM_THRESHOLD:
        await message.reply('You\'re sending messages too fast!')
        return
    
    # Add current message timestamp
    message_counts[user_id].append(current_time)
    
    # Process message normally
    await message.reply('Message received')

Auto-responder Patterns

Keyword Auto-response

RESPONSES = {
    'hello': 'Hi there!',
    'help': 'I can help you with commands. Type !commands',
    'thanks': 'You\'re welcome!',
    'bye': 'Goodbye!'
}

@client.event
async def event_friend_message(message):
    content = message.content.lower()
    
    for keyword, response in RESPONSES.items():
        if keyword in content:
            await message.reply(response)
            return

Away Message

AWAY_MODE = True
AWAY_MESSAGE = 'I\'m currently away. I\'ll respond when I\'m back!'

@client.event
async def event_friend_message(message):
    if AWAY_MODE and message.author.id != client.user.id:
        await message.reply(AWAY_MESSAGE)

Auto-forward Messages

FORWARD_TO = 'admin-user-id'

@client.event
async def event_friend_message(message):
    # Forward all messages to admin
    admin = client.get_friend(FORWARD_TO)
    if admin and message.author.id != FORWARD_TO:
        await admin.send(
            f'Message from {message.author.display_name}: {message.content}'
        )

Message Logging

Simple Logger

import datetime

@client.event
async def event_friend_message(message):
    timestamp = message.created_at.strftime('%Y-%m-%d %H:%M:%S')
    log_entry = f'[{timestamp}] {message.author.display_name}: {message.content}'
    
    # Log to file
    with open('messages.log', 'a', encoding='utf-8') as f:
        f.write(log_entry + '\n')
    
    # Also log party messages

@client.event
async def event_party_message(message):
    timestamp = message.created_at.strftime('%Y-%m-%d %H:%M:%S')
    log_entry = f'[{timestamp}] [Party] {message.author.display_name}: {message.content}'
    
    with open('messages.log', 'a', encoding='utf-8') as f:
        f.write(log_entry + '\n')

Database Logging

@client.event
async def event_friend_message(message):
    await save_to_database(
        message_type='friend',
        author_id=message.author.id,
        author_name=message.author.display_name,
        content=message.content,
        timestamp=message.created_at
    )

Party Chat Management

Announce Member Joins

@client.event
async def event_party_member_join(member):
    if member.id != client.user.id:
        await client.party.send(f'Welcome {member.display_name}!')

Party Chat Commands

@client.event
async def event_party_message(message):
    if message.author.id == client.user.id:
        return
    
    content = message.content.lower()
    
    if content == '!members':
        members = ', '.join(m.display_name for m in client.party.members)
        await message.reply(f'Members: {members}')
    
    elif content == '!count':
        count = client.party.member_count
        max_size = client.party.max_size
        await message.reply(f'{count}/{max_size} members')
    
    elif content == '!leader':
        leader = client.party.leader
        await message.reply(f'Leader: {leader.display_name}')

Best Practices

Check message length

Always ensure messages are under 256 characters

Ignore own messages

Filter out message.author.id == client.user.id to avoid loops

Use timeouts

When using wait_for(), always set a timeout

Handle errors gracefully

Catch ChatError and other exceptions

Common Issues

Message Loops

Avoid infinite loops by not replying to own messages:

# Bad - Creates infinite loop
@client.event
async def event_friend_message(message):
    await message.reply('Echo!')  # Bot replies to its own messages!

# Good - Ignores own messages
@client.event
async def event_friend_message(message):
    if message.author.id == client.user.id:
        return
    await message.reply('Echo!')

Message Too Long

Split long messages:

def split_message(text, max_length=256):
    """Split message into chunks"""
    return [text[i:i+max_length] for i in range(0, len(text), max_length)]

@client.event
async def event_friend_message(message):
    response = 'A' * 500  # Very long message
    
    for chunk in split_message(response):
        await message.reply(chunk)

Next Steps

Friends

Learn about friend management

Parties

Understand party chat context

Events

Handle message events

Commands Extension

Use the commands extension for advanced command handling

Get Started

Authentication

Core Concepts

Guides

Extensions

Documentation Index

​Overview

​Message Classes

​FriendMessage

​PartyMessage

​Receiving Messages

​Friend Messages

​Party Messages

​Sending Messages

​Send to Friend

​Send to Party

​Replying to Messages

​Message Length Limit

​Command Patterns

​Simple Command Handler

​Command with Arguments

​Party Command Handler

​Conversation Flow

​Ask and Wait for Response

​Multi-step Conversation

​Message Filtering

​Ignore Bot Messages

​Whitelist System

​Spam Protection

​Auto-responder Patterns

​Keyword Auto-response

​Away Message

​Auto-forward Messages

​Message Logging

​Simple Logger

​Database Logging

​Party Chat Management

​Announce Member Joins

​Party Chat Commands

​Best Practices