589 lines
22 KiB
Python
589 lines
22 KiB
Python
import logging
|
||
import time as _time
|
||
import hashlib
|
||
import random
|
||
import urllib.request
|
||
import json
|
||
import gzip
|
||
from datetime import datetime
|
||
from zoneinfo import ZoneInfo
|
||
from bs4 import BeautifulSoup
|
||
|
||
import psycopg2
|
||
import psycopg2.extras
|
||
import aiohttp
|
||
|
||
import config
|
||
from db import get_conn
|
||
from games.casino import get_user_length, update_user_length
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
_matches_cache: dict[str, tuple[float, list]] = {}
|
||
_sports_cache: tuple[float, list] | None = None
|
||
_last_viewed_sport_by_user: dict[int, str] = {}
|
||
_DRAW_NAMES = {"draw", "tie", "ничья"}
|
||
|
||
BET_HISTORY_DAYS = 30
|
||
_LIQUIPEDIA_CACHE_TTL = 300 # 5 minutes cache to respect Liquipedia rate limits
|
||
|
||
|
||
def _init_bets_db() -> None:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor()
|
||
cur.execute('''
|
||
CREATE TABLE IF NOT EXISTS bets (
|
||
id SERIAL PRIMARY KEY,
|
||
user_id BIGINT NOT NULL,
|
||
match_id TEXT NOT NULL,
|
||
sport TEXT NOT NULL,
|
||
home_team TEXT NOT NULL,
|
||
away_team TEXT NOT NULL,
|
||
chosen_team TEXT NOT NULL,
|
||
amount REAL NOT NULL,
|
||
odds REAL NOT NULL,
|
||
status TEXT DEFAULT 'pending',
|
||
payout REAL DEFAULT 0,
|
||
created_ts BIGINT,
|
||
resolved_ts BIGINT
|
||
)
|
||
''')
|
||
cur.execute("CREATE INDEX IF NOT EXISTS idx_bets_user ON bets(user_id, status)")
|
||
cur.execute("CREATE INDEX IF NOT EXISTS idx_bets_match ON bets(match_id, status)")
|
||
cur.execute("CREATE INDEX IF NOT EXISTS idx_bets_created ON bets(created_ts)")
|
||
cur.execute("ALTER TABLE bets ADD COLUMN IF NOT EXISTS payout REAL DEFAULT 0")
|
||
cur.execute("ALTER TABLE bets ADD COLUMN IF NOT EXISTS resolved_ts BIGINT")
|
||
|
||
|
||
try:
|
||
_init_bets_db()
|
||
except Exception:
|
||
logger.warning("Could not init bets DB at import time (will retry on first use)")
|
||
|
||
|
||
def remember_user_sport_context(user_id: int, sport_alias: str) -> None:
|
||
if sport_alias in config.ODDS_SPORTS:
|
||
_last_viewed_sport_by_user[user_id] = sport_alias
|
||
|
||
|
||
def clear_user_sport_context(user_id: int) -> None:
|
||
_last_viewed_sport_by_user.pop(user_id, None)
|
||
|
||
|
||
def get_user_sport_context(user_id: int) -> str | None:
|
||
return _last_viewed_sport_by_user.get(user_id)
|
||
|
||
|
||
async def _fetch_available_sports() -> list[dict]:
|
||
return [{"key": "dota2", "title": "🎮 Dota 2", "active": True}]
|
||
|
||
|
||
async def fetch_liquipedia_matches() -> list[dict]:
|
||
global _matches_cache
|
||
now = _time.time()
|
||
cached = _matches_cache.get("liquipedia_all")
|
||
if cached and (now - cached[0]) < _LIQUIPEDIA_CACHE_TTL:
|
||
return cached[1]
|
||
|
||
url = "https://liquipedia.net/dota2/api.php?action=parse&page=Liquipedia:Matches&format=json"
|
||
headers = {
|
||
"User-Agent": "Dota2BettingTelegramBot/1.0 (contact: danil@example.com)",
|
||
"Accept-Encoding": "gzip"
|
||
}
|
||
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(url, headers=headers, timeout=aiohttp.ClientTimeout(total=15)) as resp:
|
||
if resp.status != 200:
|
||
logger.warning(f"Liquipedia API returned {resp.status}")
|
||
return cached[1] if cached else []
|
||
|
||
data = await resp.json()
|
||
html_content = data['parse']['text']['*']
|
||
|
||
soup = BeautifulSoup(html_content, "lxml")
|
||
match_divs = soup.find_all("div", class_="match-info")
|
||
|
||
matches = []
|
||
for idx, div in enumerate(match_divs):
|
||
# Tournament
|
||
tournament_div = div.find("div", class_="match-info-tournament")
|
||
tournament = tournament_div.get_text(strip=True) if tournament_div else "Unknown Tournament"
|
||
|
||
# Teams
|
||
opponents = div.find_all("div", class_="match-info-header-opponent")
|
||
team1 = "TBD"
|
||
team2 = "TBD"
|
||
winner = None
|
||
completed = False
|
||
|
||
if len(opponents) >= 2:
|
||
o1, o2 = opponents[0], opponents[1]
|
||
team1 = o1.get_text(strip=True)
|
||
team2 = o2.get_text(strip=True)
|
||
|
||
c1 = o1.get("class", [])
|
||
c2 = o2.get("class", [])
|
||
|
||
has_win_loss = any("winner" in c or "loser" in c for c in c1 + c2)
|
||
if has_win_loss:
|
||
completed = True
|
||
if any("winner" in c for c in c1):
|
||
winner = team1
|
||
elif any("winner" in c for c in c2):
|
||
winner = team2
|
||
else:
|
||
teams = div.find_all("span", class_="block-team")
|
||
if len(teams) >= 2:
|
||
team1 = teams[0].get_text(strip=True)
|
||
team2 = teams[1].get_text(strip=True)
|
||
|
||
# Start time
|
||
timer_span = div.find("span", class_="timer-object")
|
||
timestamp = ""
|
||
if timer_span:
|
||
timestamp = timer_span.get("data-timestamp", "")
|
||
|
||
if not team1 or not team2 or team1 == "TBD" or team2 == "TBD":
|
||
continue
|
||
|
||
# ID generation
|
||
match_id = hashlib.md5(f"lp_{team1}_{team2}_{timestamp}".encode('utf-8')).hexdigest()
|
||
|
||
# Deterministic Odds
|
||
seed = int(hashlib.md5(match_id.encode('utf-8')).hexdigest(), 16) % 10**8
|
||
r = random.Random(seed)
|
||
odds_home = round(r.uniform(1.3, 3.2), 2)
|
||
margin = 1.08
|
||
prob_home = 1.0 / odds_home
|
||
prob_away = margin - prob_home
|
||
if prob_away < 0.1:
|
||
prob_away = 0.1
|
||
odds_away = round(1.0 / prob_away, 2)
|
||
|
||
matches.append({
|
||
"id": match_id,
|
||
"home": team1,
|
||
"away": team2,
|
||
"commence": datetime.fromtimestamp(int(timestamp)).isoformat() + "Z" if timestamp else "",
|
||
"timestamp": timestamp,
|
||
"completed": completed,
|
||
"winner": winner,
|
||
"odds": {
|
||
team1: odds_home,
|
||
team2: odds_away
|
||
},
|
||
"tournament": tournament
|
||
})
|
||
|
||
_matches_cache["liquipedia_all"] = (now, matches)
|
||
logger.info(f"Scraped and cached {len(matches)} matches from Liquipedia")
|
||
return matches
|
||
except Exception:
|
||
logger.exception("Failed to fetch matches from Liquipedia")
|
||
return cached[1] if cached else []
|
||
|
||
|
||
async def fetch_matches(sport_key: str = "esports_dota2") -> list[dict]:
|
||
all_matches = await fetch_liquipedia_matches()
|
||
# Return only active (not completed) matches for betting
|
||
return [m for m in all_matches if not m["completed"]]
|
||
|
||
|
||
def _get_match_outcomes(match: dict) -> list[dict[str, str | float]]:
|
||
odds = match.get("odds", {})
|
||
outcomes: list[dict[str, str | float]] = []
|
||
added: set[str] = set()
|
||
|
||
def append_outcome(code: str, name: str) -> None:
|
||
if name in odds and name not in added:
|
||
outcomes.append({"code": code, "name": name, "odds": odds[name]})
|
||
added.add(name)
|
||
|
||
home = match.get("home", "")
|
||
away = match.get("away", "")
|
||
append_outcome("1", home)
|
||
append_outcome("2", away)
|
||
return outcomes
|
||
|
||
|
||
def describe_match_outcomes(match: dict) -> str:
|
||
return ", ".join(
|
||
f"{item['code']}={item['name']} x{item['odds']:.2f}"
|
||
for item in _get_match_outcomes(match)
|
||
)
|
||
|
||
|
||
def resolve_match_outcome(match: dict, raw_choice: str) -> str | None:
|
||
choice = raw_choice.strip()
|
||
if not choice:
|
||
return None
|
||
|
||
normalized = choice.casefold()
|
||
outcomes = _get_match_outcomes(match)
|
||
|
||
for item in outcomes:
|
||
if normalized == str(item["code"]).casefold():
|
||
return str(item["name"])
|
||
|
||
for item in outcomes:
|
||
if normalized == str(item["name"]).casefold():
|
||
return str(item["name"])
|
||
|
||
try:
|
||
choice_odds = round(float(choice.replace(",", ".")), 2)
|
||
except ValueError:
|
||
return None
|
||
|
||
for item in outcomes:
|
||
if round(float(item["odds"]), 2) == choice_odds:
|
||
return str(item["name"])
|
||
|
||
return None
|
||
|
||
|
||
def format_matches(matches: list[dict], sport_alias: str, sport_label: str) -> str:
|
||
if not matches:
|
||
return f"🏟 {sport_label} [{sport_alias}] — матчей не найдено."
|
||
|
||
lines = [f"🏟 {sport_label} [{sport_alias}] — ближайшие матчи:\n"]
|
||
for i, m in enumerate(matches[:10], 1):
|
||
outcomes = _get_match_outcomes(m)
|
||
odds_str = "\n".join(
|
||
f" {item['code']}) {item['name']}: {item['odds']:.2f}"
|
||
for item in outcomes
|
||
)
|
||
|
||
start_str = ""
|
||
if m["commence"]:
|
||
try:
|
||
dt = datetime.fromisoformat(m["commence"].replace("Z", "+00:00"))
|
||
msk = dt.astimezone(ZoneInfo(config.DEFAULT_TZ))
|
||
start_str = f"\n 🕐 {msk.strftime('%d.%m %H:%M')} МСК"
|
||
except Exception:
|
||
pass
|
||
|
||
lines.append(f"{i}️⃣ {m['home']} vs {m['away']}{start_str}\n{odds_str}\n")
|
||
|
||
lines.append("Ставка: /bet [номер] [исход] [ставка]")
|
||
lines.append("Исход: 1/2. Можно писать ещё название команды или коэффициент.")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def _get_sport_label(key: str) -> str:
|
||
return "🎮 Dota 2"
|
||
|
||
|
||
async def get_formatted_matches(sport_alias: str | None) -> str:
|
||
matches = await fetch_matches()
|
||
return format_matches(matches, "dota2", "🎮 Dota 2")
|
||
|
||
|
||
async def get_match_by_index(sport_alias: str, index: int) -> dict | None:
|
||
matches = await fetch_matches()
|
||
if 0 < index <= len(matches):
|
||
return matches[index - 1]
|
||
return None
|
||
|
||
|
||
def place_bet(user_id: int, match: dict, sport: str, chosen_team: str, amount: float) -> tuple[bool, str]:
|
||
current = get_user_length(user_id)
|
||
if current is None:
|
||
return False, "Сначала заведи счёт через /penis, братуха."
|
||
if current <= 0:
|
||
return False, "🚫 С кредитом ставки не принимаем."
|
||
if amount <= 0:
|
||
return False, "Ставка должна быть больше нуля."
|
||
if amount > config.BET_MAX_AMOUNT:
|
||
return False, f"Максимальная ставка — {config.BET_MAX_AMOUNT} см."
|
||
if round(amount, 2) > round(current, 2):
|
||
return False, f"У тебя {current:.1f} см, а ставишь {amount:.1f}. Не хватает, фраер."
|
||
|
||
team_odds = match["odds"].get(chosen_team)
|
||
if team_odds is None:
|
||
return False, f"Исход не найден. Доступные: {describe_match_outcomes(match)}"
|
||
|
||
new_length = update_user_length(user_id, -amount)
|
||
if new_length is None:
|
||
return False, "Ошибка БД."
|
||
|
||
now_ts = int(_time.time())
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor()
|
||
cur.execute('''
|
||
INSERT INTO bets
|
||
(user_id, match_id, sport, home_team, away_team,
|
||
chosen_team, amount, odds, status, payout, created_ts)
|
||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'pending', 0, %s)
|
||
''', (
|
||
user_id, match["id"], sport, match["home"], match["away"],
|
||
chosen_team, amount, team_odds, now_ts,
|
||
))
|
||
except psycopg2.Error:
|
||
logger.exception("Failed to place bet")
|
||
update_user_length(user_id, amount)
|
||
return False, "Ошибка БД."
|
||
|
||
potential = round(amount * team_odds, 1)
|
||
return True, (
|
||
f"✅ Ставка принята!\n"
|
||
f"📌 {chosen_team} (x{team_odds:.2f})\n"
|
||
f"💰 Ставка: {amount:.1f} см\n"
|
||
f"🎯 Возможный выигрыш: {potential:.1f} см\n"
|
||
f"📏 Остаток: {new_length:.1f} см"
|
||
)
|
||
|
||
|
||
def get_user_bets(user_id: int) -> str:
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
|
||
cur.execute('''
|
||
SELECT * FROM bets
|
||
WHERE user_id = %s AND status = 'pending'
|
||
ORDER BY created_ts DESC LIMIT 10
|
||
''', (user_id,))
|
||
rows = cur.fetchall()
|
||
except psycopg2.Error:
|
||
return "Ошибка БД."
|
||
|
||
if not rows:
|
||
return "У тебя нет активных ставок."
|
||
|
||
lines = ["📋 Твои активные ставки:\n"]
|
||
for r in rows:
|
||
potential = round(r["amount"] * r["odds"], 1)
|
||
created = ""
|
||
if r["created_ts"]:
|
||
dt = datetime.fromtimestamp(r["created_ts"], tz=ZoneInfo(config.DEFAULT_TZ))
|
||
created = f" 📅 {dt.strftime('%d.%m %H:%M')}\n"
|
||
lines.append(
|
||
f"• {r['home_team']} vs {r['away_team']}\n"
|
||
f" {r['chosen_team']} (x{r['odds']:.2f}), {r['amount']:.1f} см → {potential:.1f} см\n"
|
||
f"{created}"
|
||
)
|
||
return "\n".join(lines)
|
||
|
||
|
||
def get_user_bet_history(user_id: int) -> str:
|
||
cutoff_ts = int(_time.time() - BET_HISTORY_DAYS * 86400)
|
||
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
|
||
cur.execute('''
|
||
SELECT * FROM bets
|
||
WHERE user_id = %s AND created_ts >= %s
|
||
ORDER BY created_ts DESC LIMIT 50
|
||
''', (user_id, cutoff_ts))
|
||
rows = cur.fetchall()
|
||
except psycopg2.Error:
|
||
logger.exception("Failed to get bet history")
|
||
return "Ошибка БД."
|
||
|
||
if not rows:
|
||
return "📋 За последний месяц ставок не было."
|
||
|
||
total_bet = total_won = total_lost = 0.0
|
||
wins = losses = pending = 0
|
||
lines = [f"📋 История ставок за {BET_HISTORY_DAYS} дней:\n"]
|
||
|
||
for r in rows:
|
||
status = r["status"]
|
||
amount = float(r["amount"])
|
||
odds_val = float(r["odds"])
|
||
payout_raw = float(r["payout"] or 0)
|
||
|
||
total_bet += amount
|
||
|
||
if status == "won":
|
||
wins += 1
|
||
actual_payout = payout_raw if payout_raw > 0 else round(amount * odds_val, 1)
|
||
total_won += actual_payout
|
||
status_icon = "✅"
|
||
result_text = f"+{actual_payout:.1f} см"
|
||
elif status == "lost":
|
||
losses += 1
|
||
total_lost += amount
|
||
status_icon = "❌"
|
||
result_text = f"-{amount:.1f} см"
|
||
else:
|
||
pending += 1
|
||
status_icon = "⏳"
|
||
result_text = f"ожидание → {round(amount * odds_val, 1):.1f} см"
|
||
|
||
created = ""
|
||
if r["created_ts"]:
|
||
dt = datetime.fromtimestamp(r["created_ts"], tz=ZoneInfo(config.DEFAULT_TZ))
|
||
created = dt.strftime('%d.%m %H:%M')
|
||
|
||
lines.append(
|
||
f"{status_icon} {r['home_team']} vs {r['away_team']}\n"
|
||
f" {r['chosen_team']} (x{odds_val:.2f}) | {amount:.1f} см | {result_text}\n"
|
||
f" 📅 {created}"
|
||
)
|
||
|
||
net = total_won - total_lost
|
||
net_sign = "+" if net >= 0 else ""
|
||
lines.append("")
|
||
lines.append("━━━ 📊 СТАТИСТИКА ━━━")
|
||
lines.append(f"🎰 Всего ставок: {len(rows)}")
|
||
lines.append(f"✅ Побед: {wins}")
|
||
lines.append(f"❌ Поражений: {losses}")
|
||
if pending:
|
||
lines.append(f"⏳ В ожидании: {pending}")
|
||
lines.append(f"💰 Поставлено: {total_bet:.1f} см")
|
||
lines.append(f"🏆 Выиграно: +{total_won:.1f} см")
|
||
lines.append(f"💸 Проиграно: -{total_lost:.1f} см")
|
||
lines.append(f"📈 Итого: {net_sign}{net:.1f} см")
|
||
if wins + losses > 0:
|
||
lines.append(f"📊 Винрейт: {wins / (wins + losses) * 100:.0f}%")
|
||
|
||
return "\n".join(lines)
|
||
|
||
|
||
def cleanup_old_bets() -> int:
|
||
cutoff_ts = int(_time.time() - BET_HISTORY_DAYS * 86400)
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor()
|
||
cur.execute(
|
||
"DELETE FROM bets WHERE status != 'pending' AND created_ts < %s",
|
||
(cutoff_ts,),
|
||
)
|
||
deleted = cur.rowcount
|
||
if deleted > 0:
|
||
logger.info(f"Cleaned up {deleted} old bets")
|
||
return deleted
|
||
except psycopg2.Error:
|
||
logger.exception("Failed to cleanup old bets")
|
||
return 0
|
||
|
||
|
||
_REFUND_AFTER_SECONDS = 7 * 86400 # авторефанд ставок старше 7 дней
|
||
|
||
|
||
def _refund_expired_bets() -> list[tuple[int, str]]:
|
||
"""Возвращает деньги за ставки, которые висят более 7 дней без результата."""
|
||
cutoff = int(_time.time()) - _REFUND_AFTER_SECONDS
|
||
notifications: list[tuple[int, str]] = []
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
|
||
cur.execute(
|
||
"SELECT * FROM bets WHERE status = 'pending' AND created_ts < %s",
|
||
(cutoff,),
|
||
)
|
||
expired = cur.fetchall()
|
||
if not expired:
|
||
return []
|
||
wcur = conn.cursor()
|
||
now_ts = int(_time.time())
|
||
for bet in expired:
|
||
update_user_length(bet["user_id"], bet["amount"])
|
||
wcur.execute(
|
||
"UPDATE bets SET status = 'refunded', resolved_ts = %s WHERE id = %s",
|
||
(now_ts, bet["id"]),
|
||
)
|
||
notifications.append((
|
||
bet["user_id"],
|
||
f"↩️ Ставка возвращена\n"
|
||
f"🏟 {bet['home_team']} vs {bet['away_team']}\n"
|
||
f"📌 {bet['chosen_team']} — результат так и не пришёл\n"
|
||
f"💰 Возврат: {bet['amount']:.1f} см",
|
||
))
|
||
logger.info("Refunded expired bet id=%s user=%s amount=%s", bet["id"], bet["user_id"], bet["amount"])
|
||
except psycopg2.Error:
|
||
logger.exception("Failed to refund expired bets")
|
||
return notifications
|
||
|
||
|
||
async def settle_bets() -> list[tuple[int, str]]:
|
||
"""Возвращает список (user_id, текст_уведомления) для отправки в Telegram."""
|
||
notifications: list[tuple[int, str]] = []
|
||
|
||
# Сначала авторефанд совсем старых ставок
|
||
notifications.extend(_refund_expired_bets())
|
||
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
|
||
cur.execute("SELECT DISTINCT match_id FROM bets WHERE status = 'pending'")
|
||
pending = cur.fetchall()
|
||
except psycopg2.Error:
|
||
return notifications
|
||
|
||
if not pending:
|
||
return notifications
|
||
|
||
all_matches = await fetch_liquipedia_matches()
|
||
match_map = {m["id"]: m for m in all_matches}
|
||
now_ts = int(_time.time())
|
||
|
||
for row in pending:
|
||
match_id = row["match_id"]
|
||
event = match_map.get(match_id)
|
||
if not event or not event.get("completed"):
|
||
continue
|
||
|
||
winner = event.get("winner")
|
||
if not winner:
|
||
continue
|
||
|
||
is_draw = (winner.casefold() in _DRAW_NAMES or winner == "Draw")
|
||
|
||
try:
|
||
with get_conn() as conn:
|
||
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
|
||
cur.execute(
|
||
"SELECT * FROM bets WHERE match_id = %s AND status = 'pending'",
|
||
(match_id,),
|
||
)
|
||
bets = cur.fetchall()
|
||
|
||
wcur = conn.cursor()
|
||
for bet in bets:
|
||
chosen = bet["chosen_team"]
|
||
if is_draw:
|
||
bet_won = chosen.casefold() in _DRAW_NAMES or chosen == "Draw"
|
||
else:
|
||
bet_won = chosen == winner
|
||
|
||
if bet_won:
|
||
winnings = round(bet["amount"] * bet["odds"], 1)
|
||
update_user_length(bet["user_id"], winnings)
|
||
wcur.execute(
|
||
"UPDATE bets SET status = 'won', payout = %s, resolved_ts = %s WHERE id = %s",
|
||
(winnings, now_ts, bet["id"]),
|
||
)
|
||
notifications.append((
|
||
bet["user_id"],
|
||
f"🎉 Ставка сыграла!\n"
|
||
f"🏟 {bet['home_team']} vs {bet['away_team']}\n"
|
||
f"📌 {bet['chosen_team']} (x{bet['odds']:.2f})\n"
|
||
f"💰 Выигрыш: +{winnings:.1f} см",
|
||
))
|
||
logger.info("Bet won: user=%s match=%s winnings=%s", bet["user_id"], match_id, winnings)
|
||
else:
|
||
wcur.execute(
|
||
"UPDATE bets SET status = 'lost', payout = 0, resolved_ts = %s WHERE id = %s",
|
||
(now_ts, bet["id"]),
|
||
)
|
||
notifications.append((
|
||
bet["user_id"],
|
||
f"❌ Ставка не сыграла\n"
|
||
f"🏟 {bet['home_team']} vs {bet['away_team']}\n"
|
||
f"📌 {bet['chosen_team']} (x{bet['odds']:.2f})\n"
|
||
f"💸 Потеряно: {bet['amount']:.1f} см",
|
||
))
|
||
logger.info("Bet lost: user=%s match=%s amount=%s", bet["user_id"], match_id, bet["amount"])
|
||
except psycopg2.Error:
|
||
logger.exception("Failed to settle bets")
|
||
|
||
cleanup_old_bets()
|
||
return notifications
|
||
|
||
|
||
async def debug_sports() -> str:
|
||
return "🎮 Dota 2 — Scraper Liquipedia активен. Odds API отключен."
|