Ниже простой рабочий вариант под aiogram 3 + asyncio. aiogram 3 — асинхронный фреймворк для Telegram Bot API на Python 3.10+, а запуск через Dispatcher.start_polling() есть в актуальной документации. (Aiogram Documentation)

Установка:

bash
pip install aiogram

Запуск:

bash
export BOT_TOKEN="ТОКЕН_ОТ_BOTFATHER"
python bot.py

bot.py:

python
import asyncio
import logging
import os
import random
import re
from dataclasses import dataclass
from decimal import Decimal, ROUND_HALF_UP
from typing import Literal

from aiogram import Bot, Dispatcher, F, Router
from aiogram.client.default import DefaultBotProperties
from aiogram.enums import ParseMode
from aiogram.filters import CommandStart
from aiogram.types import Message

TOKEN = os.getenv("BOT_TOKEN")

START_BALANCE = Decimal("10000")
MIN_BET = Decimal("1")

MULT_SIMPLE = Decimal("1.98")
MULT_NUMBER = Decimal("35.98")

RED_NUMBERS = {
    1, 3, 5, 7, 9, 12, 14, 16, 18,
    19, 21, 23, 25, 27, 30, 32, 34, 36,
}
BLACK_NUMBERS = {
    2, 4, 6, 8, 10, 11, 13, 15, 17,
    20, 22, 24, 26, 28, 29, 31, 33, 35,
}

balances: dict[int, Decimal] = {}

router = Router()

BetKind = Literal["color", "parity", "number", "range"]


@dataclass
class Bet:
    raw: str
    kind: BetKind
    value: object
    multiplier: Decimal


def money(value: Decimal) -> str:
    value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
    text = format(value, "f")
    if "." in text:
        text = text.rstrip("0").rstrip(".")
    return text


def user_balance(user_id: int) -> Decimal:
    if user_id not in balances:
        balances[user_id] = START_BALANCE
    return balances[user_id]


def normalize(text: str) -> str:
    return text.lower().replace("ё", "е").strip()


def parse_amount(text: str) -> Decimal | None:
    text = text.replace(",", ".")
    try:
        amount = Decimal(text)
    except Exception:
        return None

    if amount < MIN_BET:
        return None

    if amount.as_tuple().exponent < -2:
        return None

    return amount


def parse_bet(token: str) -> Bet:
    raw = token
    token = normalize(token)

    red_aliases = {"к", "кр", "красное", "красный", "red"}
    black_aliases = {"ч", "чер", "черное", "черный", "black"}
    even_aliases = {"чет", "четное", "even"}
    odd_aliases = {"нечет", "нечетное", "odd"}

    if token in red_aliases:
        return Bet(raw=raw, kind="color", value="red", multiplier=MULT_SIMPLE)

    if token in black_aliases:
        return Bet(raw=raw, kind="color", value="black", multiplier=MULT_SIMPLE)

    if token in even_aliases:
        return Bet(raw=raw, kind="parity", value="even", multiplier=MULT_SIMPLE)

    if token in odd_aliases:
        return Bet(raw=raw, kind="parity", value="odd", multiplier=MULT_SIMPLE)

    if re.fullmatch(r"\d{1,2}", token):
        number = int(token)
        if 0 <= number <= 36:
            return Bet(raw=raw, kind="number", value=number, multiplier=MULT_NUMBER)
        raise ValueError(f"число `{raw}` должно быть от 0 до 36")

    match = re.fullmatch(r"(\d{1,2})-(\d{1,2})", token)
    if match:
        start = int(match.group(1))
        end = int(match.group(2))

        if not (1 <= start <= end <= 36):
            raise ValueError(f"диапазон `{raw}` должен быть от 1 до 36 и слева направо")

        return Bet(raw=raw, kind="range", value=(start, end), multiplier=MULT_SIMPLE)

    raise ValueError(f"не понимаю тип ставки `{raw}`")


def is_win(bet: Bet, result: int) -> bool:
    if bet.kind == "number":
        return result == bet.value

    if bet.kind == "range":
        start, end = bet.value
        return start <= result <= end

    if result == 0:
        return False

    if bet.kind == "color":
        if bet.value == "red":
            return result in RED_NUMBERS
        if bet.value == "black":
            return result in BLACK_NUMBERS

    if bet.kind == "parity":
        if bet.value == "even":
            return result % 2 == 0
        if bet.value == "odd":
            return result % 2 == 1

    return False


def result_color(result: int) -> str:
    if result == 0:
        return "🟢"
    if result in RED_NUMBERS:
        return "🔴"
    return "⚫"


@router.message(CommandStart())
async def start_handler(message: Message) -> None:
    uid = message.from_user.id
    balance = user_balance(uid)

    await message.answer(
        "🎡 <b>Рулетка | Lites 🃏</b>\n\n"
        f"Твой баланс: <b>{money(balance)}</b>\n\n"
        "Команда:\n"
        "<code>рул 100 к</code>\n"
        "<code>рул 50 чет 1-18 7 30-32</code>\n\n"
        "Типы ставок:\n"
        "• к / ч — цвет, x1.98\n"
        "• чет / нечет — x1.98\n"
        "• 0-36 как отдельное число — x35.98\n"
        "• 1-18 / 19-36 / любые диапазоны 1-36 — x1.98\n\n"
        "Важно: сумма ставится на каждый указанный тип."
    )


@router.message(F.text.regexp(r"(?i)^рул(\s+|$)"))
async def roulette_handler(message: Message) -> None:
    uid = message.from_user.id
    parts = message.text.split()

    if len(parts) < 3:
        await message.answer(
            "❌ Формат: <code>рул [сумма] [тип]</code>\n"
            "Пример: <code>рул 100 к</code>\n"
            "Пример: <code>рул 50 1-18 19-36 7 чет</code>"
        )
        return

    amount = parse_amount(parts[1])
    if amount is None:
        await message.answer(
            "❌ Сумма должна быть числом от 1.\n"
            "Пример: <code>рул 100 к</code>"
        )
        return

    try:
        bets = [parse_bet(token) for token in parts[2:]]
    except ValueError as error:
        await message.answer(f"❌ {error}")
        return

    total_stake = amount * len(bets)
    balance = user_balance(uid)

    if balance < total_stake:
        await message.answer(
            "❌ Недостаточно монет.\n"
            f"Баланс: <b>{money(balance)}</b>\n"
            f"Нужно: <b>{money(total_stake)}</b>\n\n"
            "Потому что сумма ставится на каждый указанный тип."
        )
        return

    balances[uid] -= total_stake

    result = random.randint(0, 36)
    won_bets: list[Bet] = []
    payout = Decimal("0")

    for bet in bets:
        if is_win(bet, result):
            won_bets.append(bet)
            payout += amount * bet.multiplier

    balances[uid] += payout
    profit = payout - total_stake

    won_text = ", ".join(b.raw for b in won_bets) if won_bets else "нет"
    sign = "+" if profit >= 0 else ""

    await message.answer(
        "🎡 <b>Рулетка | Lites 🃏</b>\n\n"
        f"Выпало: <b>{result}</b> {result_color(result)}\n"
        f"Ставка на 1 тип: <b>{money(amount)}</b>\n"
        f"Типов ставок: <b>{len(bets)}</b>\n"
        f"Всего поставлено: <b>{money(total_stake)}</b>\n\n"
        f"Выиграли ставки: <b>{won_text}</b>\n"
        f"Выплата: <b>{money(payout)}</b>\n"
        f"Итог: <b>{sign}{money(profit)}</b>\n\n"
        f"Баланс: <b>{money(balances[uid])}</b>"
    )


@router.message(F.text.lower() == "баланс")
async def balance_handler(message: Message) -> None:
    uid = message.from_user.id
    await message.answer(f"💰 Баланс: <b>{money(user_balance(uid))}</b>")


async def main() -> None:
    if not TOKEN:
        raise RuntimeError("Добавь токен в переменную окружения BOT_TOKEN")

    logging.basicConfig(level=logging.INFO)

    bot = Bot(
        token=TOKEN,
        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
    )

    dp = Dispatcher()
    dp.include_router(router)

    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())

Примеры:

text
рул 100 к
рул 50 чет
рул 25 7
рул 10 1-18 19-36 30-32 7 к нечет

Главная логика: если человек пишет рул 100 к 7 1-18, то это 3 ставки по 100, всего снимается 300.
Проверь себя: какая будет общая ставка у команды рул 50 к чет 1-18 7?