Создание IRC-ботов: фреймворки для Python, Node.js, Go и Rust

В этом практическом туториале я покажу, как быстро написать простой IRC-бот на разных языках программирования и с использованием разных фреймворков.

Почему Python?

Python сейчас один из самых популярных языков программирования, и в нём есть множество библиотек для обработки текста. Я сам часто работаю с Python-фреймворками вроде FastAPI и люблю интегрировать такие системы в свои проекты.

Почему Node.js?

Node.js позволяет писать бэкенд на JavaScript, причём это очень современный подход. Интеграция с множеством JS-фреймворков делает его универсальным инструментом. Если вы много программируете, вам сложно будет обойти Node.js.

Почему Go?

Go отлично подходит для IRC-ботов благодаря встроенным возможностям параллелизма через Goroutines и простой организации сетевого программирования. Компилируемые бинарники получаются компактными и быстрыми, идеально подходят для ботов, которые работают круглосуточно.

Почему Rust?

Независимо от проекта, мы всегда рассматриваем возможность его реализации на Rust. Поэтому здесь я быстро покажу реализацию на Rust, чтобы продемонстрировать её простоту. Rust обеспечивает безопасность памяти без garbage collector, что идеально для долгоживущих ботов.

Основные принципы IRC-бота

Чтобы построить нормальный скелет приложения или найти начало и середину, нужно отметить основные задачи IRC-бота или хорошо их понять. Вместо UML-диаграмм или блок-схем мы работаем с простым списком задач.

Все IRC-боты на уровне ядра выполняют следующее:

Подключение по TCP к IRC-серверу Установка никнейма Опционально: аутентификация (NickServ / SASL) Присоединение к каналам Прослушивание сообщений (события) Реакция на PRIVMSG При необходимости: отправка ответов

Конечно, функционал можно расширять до бесконечности. Здесь мы также посмотрим на систему плагинов и асинхронные методы.

У нас много туториалов, которые объясняют всё с нуля, но в этом практическом гайде мы исходим из базовых знаний и сразу переходим к установкам и необходимым зависимостям.

Python – irc (самый простой вход)

Установка

pip install irc

Минимальный бот

import irc.bot

class MyBot(irc.bot.SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "MyPyBot"
        irc.bot.SingleServerIRCBot.__init__(self, server, nickname, nickname)

    def on_welcome(self, connection, event):
        connection.join("#ircmania")

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        if msg == "!ping":
            connection.privmsg(event.target, "pong")

if __name__ == "__main__":
    MyBot().start()

Что здесь происходит?

• on_welcome → присоединение к каналу
• on_pubmsg → сообщения в канале
• простая логика со строками для команд

Принцип должен быть ясен. Теперь можно изучить фреймворки. С их помощью всё становится ещё проще. Python предлагает множество подходящих фреймворков.

Python – irc3 (современный и модульный)

irc3 это модерный, основанный на плагинах фреймворк для IRC на Python. Он предоставляет встроенные обработчики команд, автоматическую логику переподключения и чистую архитектуру с поддержкой плагинов. Идеален для крупных ботов с большим количеством функций.

Установка

pip install irc3

Бот

import irc3
from irc3.plugins.command import command

@irc3.plugin
class Plugin:
    def __init__(self, bot):
        self.bot = bot

    @command
    def ping(self, mask, target, args):
        """!ping command"""
        self.bot.privmsg(target, "pong")

config = dict(
    nick='MyIrc3Bot',
    autojoins=['#ircmania'],
    host='irc.IRC-Mania.de',
    port=6667,
    includes=['irc3.plugins.core', __name__],
)

irc3.IrcBot(**config).run()

Преимущество: плагины и команды из коробки

Python – pydle (асинхронный и современный)

pydle это современный асинхронный IRC-фреймворк. Главное преимущество перед irc3 — встроенная поддержка async/await, что отлично подходит для ботов с интенсивными операциями ввода-вывода. pydle легче и гибче, но имеет меньше встроенных функций, чем irc3.

Установка

pip install pydle

Бот

import pydle

class MyBot(pydle.Client):
    async def on_connect(self):
        await self.join('#ircmania')

    async def on_message(self, target, source, message):
        if message == "!ping":
            await self.message(target, "pong")

client = MyBot("MyPydleBot")
client.run("irc.IRC-Mania.de", tls=False)

Node.js – irc-framework

Node.js прекрасно подходит для IRC-ботов благодаря его событийной архитектуре. Модель неблокирующего ввода-вывода идеально соответствует системе обмена сообщениями IRC. irc-framework это самая популярная библиотека с отличными функциями переподключения и системой плагинов.

Установка

npm install irc-framework

Бот

const IRC = require('irc-framework');

const bot = new IRC.Client();

bot.connect({
    host: 'irc.IRC-Mania.de',
    port: 6667,
    nick: 'MyNodeBot'
});

bot.on('registered', () => {
    bot.join('#ircmania');
});

bot.on('message', (event) => {
    if (event.message === '!ping') {
        bot.say(event.target, 'pong');
    }
});

Go – go-ircevent

Установка

go get github.com/thoj/go-ircevent

Бот

package main

import (
    "github.com/thoj/go-ircevent"
    "fmt"
)

func main() {
    bot := irc.IRC("MyGoBot", "MyGoBot")
    
    bot.AddCallback("001", func(e irc.Event) {
        bot.Join("#ircmania")
    })
    
    bot.AddCallback("PRIVMSG", func(e irc.Event) {
        if e.Message() == "!ping" {
            bot.Privmsg(e.Arguments[0], "pong")
        }
    })
    
    err := bot.Connect("irc.IRC-Mania.de:6667")
    if err != nil {
        fmt.Println(err)
        return
    }

    bot.Loop()
}

Rust – irc crate

Rust хороший выбор для IRC-ботов, так как обеспечивает безопасность памяти без garbage collector. Это означает, что Rust-боты получаются долгоживущими и стабильными.

Установка

cargo add irc

Бот

use irc::client::prelude::*;

fn main() {
    let config = Config {
        nickname: Some("MyRustBot".to_owned()),
        server: Some("irc.IRC-Mania.de".to_owned()),
        channels: vec!["#ircmania".to_owned()],
        ..Default::default()
    };

    let mut client = Client::from_config(config).unwrap();
    client.identify().unwrap();

    for message in client.stream().unwrap() {
        if let Ok(message) = message {
            if let Command::PRIVMSG(_, ref msg) = message.command {
                if msg == "!ping" {
                    let _ = client.send_privmsg("#ircmania", "pong");
                }
            }
        }
    }
}

Интеграция IRC-ботов в Python веб-фреймворки

Да, IRC-ботов можно отлично интегрировать в современные Python веб-фреймворки! Это открывает совершенно новые возможности для веб-приложений с поддержкой чата.

Обзор: Python веб-фреймворки для IRC-ботов

Интеграция с FastAPI (идеально…быстро)

from fastapi import FastAPI, WebSocket
import asyncio
import threading
from irc.bot import SingleServerIRCBot

app = FastAPI()

class IRCBot(SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "FastAPIBot"
        super().__init__(server, nickname, nickname)
        self.messages = []

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        self.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": msg,
            "timestamp": asyncio.get_event_loop().time()
        })

irc_bot = IRCBot()
threading.Thread(target=irc_bot.start, daemon=True).start()

@app.get("/messages")
async def get_messages():
    return {"messages": irc_bot.messages[-20:]}

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        await websocket.send_json({"messages": irc_bot.messages[-5:]})
        await asyncio.sleep(1)

Интеграция со Streamlit (очень хорошо)

import streamlit as st
import threading
from irc.bot import SingleServerIRCBot

class StreamlitIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "StreamlitBot", "StreamlitBot")
        if 'messages' not in st.session_state:
            st.session_state.messages = []

    def on_pubmsg(self, connection, event):
        st.session_state.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": event.arguments[0],
            "time": time.strftime("%H:%M:%S")
        })

if 'irc_bot' not in st.session_state:
    st.session_state.irc_bot = StreamlitIRCBot()
    threading.Thread(target=st.session_state.irc_bot.start, daemon=True).start()

st.title("IRC Bot Dashboard")
for msg in reversed(st.session_state.messages[-10:]):
    st.chat_message(msg["user"]).write(f"**{msg['channel']}**: {msg['message']}")

Интеграция с Django (хорошо)

# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from irc.bot import SingleServerIRCBot
import threading

class DjangoIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "DjangoBot", "DjangoBot")

django_bot = DjangoIRCBot()
threading.Thread(target=django_bot.start, daemon=True).start()

@csrf_exempt
def send_message(request):
    if request.method == 'POST':
        channel = request.POST.get('channel')
        message = request.POST.get('message')
        django_bot.connection.privmsg(channel, message)
        return JsonResponse({'status': 'sent'})

Преимущества интеграции с фреймворками

• Веб-интерфейс: управление через браузер вместо командной строки
• API-эндпоинты: другие приложения могут взаимодействовать с ботом
• Сохранение данных: хранение истории чатов в базах данных
• Мониторинг: живые панели управления для отслеживания активности бота
• Многопользовательский доступ: несколько пользователей могут управлять ботом
• Режим реального времени: интеграция WebSocket для мгновенных обновлений

Надеюсь, эти краткие обзоры вдохновят тебя вернуться к IRC-ботам и Internet Relay Chat. На этом сайте, а также на IRC-Mania.de ты найдёшь множество подробных туториалов для начинающих.

Что есть общего у всех ботов

В конце концов все языки программирования готовят по одному рецепту, но не всегда с одной и той же водой:

Типичные возможности IRC-ботов (следующий уровень)

Если ты пойдёшь дальше, встретишь эти классические функции:

🔹 Логика переподключения Важно: IRC часто разрывает соединения!

Вверху мы начали программирование с простых функций. Если ты хочешь написать что-то более серьёзное, имеет смысл создать небольшой каркас функций. Не нужны диаграммы классов или диаграммы вариантов использования, но хотя бы общее направление было бы полезно.

Я покажу тебе архитектуру IRC-бота, готовую к production, и объясню, как правильно разделить работу с несколькими каналами и async/threads, чтобы бот не падал через два дня и не терял сообщения.

Архитектура IRC-бота для production

Целевой образ

┌─────────────────┐
│  IRC Client     │ ← Соединение с сервером
└─────────┬───────┘
│
┌─────────▼───────┐
│ Event Dispatcher│ ← Маршрутизация событий
└───────┬─┬───────┘
│ │
┌───────▼─▼───────┐
│ Plugin System   │ ← Функциональность
└─────────────────┘
│
┌────────▼─┐  ┌────▼────────┐
│ Plugin A │  │ Plugin B    │  ← Функции
└──────────┘  └─────────────┘

Архитектура

bot/
 ├── core.py        (IRC client)
 ├── dispatcher.py  (event routing)
 ├── plugins/
 │     ├── ping.py
 │     ├── logger.py
 │     └── admin.py
 └── main.py

Основной бот (async + переподключение)

import pydle
import asyncio

class CoreBot(pydle.Client):
    def __init__(self, nickname, channels):
        super().__init__(nickname)
        self.channels = channels
        self.plugins = []
        self.reconnect_delay = 5

    async def on_connect(self):
        for channel in self.channels:
            await self.join(channel)

    async def on_disconnect(self, expected):
        while True:
            try:
                await self.reconnect()
                break
            except:
                await asyncio.sleep(self.reconnect_delay)

    async def on_message(self, target, source, message):
        for plugin in self.plugins:
            await plugin.handle_message(self, target, source, message)

    def register_plugin(self, plugin):
        self.plugins.append(plugin)

Система плагинов

class PingPlugin:
    async def handle_message(self, bot, target, source, message):
        if message == "!ping":
            await bot.message(target, "pong")

Основной запуск

from core import CoreBot
from plugins.ping import PingPlugin

bot = CoreBot("MyBot", ["#dev", "#test"])
bot.register_plugin(PingPlugin())

bot.run("irc.libera.chat", tls=False)

Поведение в нескольких каналах

Всё происходит автоматически:

• Bot присоединяется к #dev и #test
• Bot отвечает независимо от канала

Многопоточная архитектура (если НЕ используешь async)

Альтернативный подход (традиционный, например Python irc lib):

Проблема:

IRC цикл блокирует работу, плагины замедляют всё

Решение: рабочие потоки IRC Thread ───► Event Queue ───► Worker Threads Схема:

from queue import Queue
import threading

event_queue = Queue()

def worker():
    while True:
        event = event_queue.get()
        handle_event(event)

threading.Thread(target=worker, daemon=True).start()

IRC callback:

def on_message(msg):
    event_queue.put(msg)

Преимущества:

• IRC остаётся быстрым
• Тяжёлые операции не блокируют систему

Production-функции (критично для реальных ботов)

1. Автоматическое переподключение

async def on_disconnect(self, expected):
    while True:
        try:
            await self.reconnect()
            break
        except:
            await asyncio.sleep(5)

2. Rate Limiting (защита от флуда)

IRC серверы выкидывают за спам.

import time

last_send = 0

def safe_send(bot, target, msg):
    global last_send
    if time.time() - last_send < 1:
        time.sleep(1)
    bot.message(target, msg)
    last_send = time.time()

3. SASL / NickServ авторизация

CAP REQ :sasl
AUTHENTICATE PLAIN

нужна для:

• зарезервированных ников
• IRC сетей вроде Libera

4. Логирование

async def on_message(self, target, source, message):
    print(f"[{target}] {source}: {message}")

лучше использовать:

• SQLite / PostgreSQL
• Elasticsearch (для больших ботов)

5. Hot Reload плагинов (продвинуто)

import importlib

def reload_plugin(module):
    importlib.reload(module)

позволяет:

• обновлять бота без отключения

Production архитектура (итоговая картина)

IRC Server
│
Async IRC Client
│
┌───────────▼───────────┐
│ Event Dispatcher       │
└───────┬───────┬───────┘
│       │
Plugin System   Logger
│
Thread Pool (optional heavy tasks)

Настоящий IRC-бот это не скрипт, а:

Event-driven async система + архитектура плагинов + слой надёжности