max.py

import asyncio
import logging
import threading
import requests
import tempfile
import os
from dotenv import load_dotenv
from pymax import SocketMaxClient
from pymax.payloads import UserAgentPayload
from pymax.types import Message
from pymax.static.enum import AttachType
import telebot
import ssl

logging.basicConfig(level=logging.INFO)

# Отключаем проверку SSL
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
# Загрузка окружения из .env файла
load_dotenv(".env")

# Токен телеграм бота
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
# ID чата
CURRENT_CHAT_ID = os.getenv("CURRENT_CHAT_ID")
# Номер телефона
PHONE_NUMBER = os.getenv("PHONE_NUMBER")

# Инициализация telebot
tb = telebot.TeleBot(TELEGRAM_BOT_TOKEN)

client = SocketMaxClient(
    phone=PHONE_NUMBER,
    work_dir="./cache",
    headers=UserAgentPayload(device_type="DESKTOP"),
    reconnect=True,
    reconnect_delay=5.0,
)

# Переопределяем SSL контекст
client._ssl_context = ssl_context



def send_file_to_telegram(file_url: str, filename: str, caption: str = ""):
    """Отправка файла в Telegram"""
    try:
        if CURRENT_CHAT_ID:
            # Скачиваем файл
            response = requests.get(file_url)
            response.raise_for_status()

            # Сохраняем во временный файл
            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(filename)[1]) as temp_file:
                temp_file.write(response.content)
                temp_file_path = temp_file.name

            # Отправляем в Telegram
            with open(temp_file_path, 'rb') as file_to_send:
                tb.send_document(
                    chat_id=CURRENT_CHAT_ID,
                    document=file_to_send,
                    visible_file_name=filename,
                    caption=caption
                )

            # Удаляем временный файл
            os.unlink(temp_file_path)

            logging.info(f"Файл {filename} отправлен в Telegram")
    except Exception as e:
        logging.error(f"Ошибка отправки файла в Telegram: {e}")


def send_photo_to_telegram(photo_url: str, caption: str = ""):
    """Отправка фото в Telegram"""
    try:
        if CURRENT_CHAT_ID:
            tb.send_photo(
                chat_id=CURRENT_CHAT_ID,
                photo=photo_url,
                caption=caption
            )
            logging.info("Фото отправлено в Telegram")
    except Exception as e:
        logging.error(f"Ошибка отправки фото в Telegram: {e}")


def send_text_to_telegram(text: str):
    """Отправка текста в Telegram"""
    try:
        if CURRENT_CHAT_ID:
            tb.send_message(
                chat_id=CURRENT_CHAT_ID,
                text=text,
                parse_mode='HTML'
            )
            logging.info("Сообщение отправлено в Telegram")
        else:
            logging.warning("ID чата не определен. Отправьте /start в чате")
    except Exception as e:
        logging.error(f"Ошибка отправки в Telegram: {e}")


async def get_sender_info(client, sender_id: int) -> str:
    """Получение информации об отправителе"""
    try:
        user = await client.get_user(sender_id)
        if user and user.names:
            name = user.names[0]
            full_name = f"{name.first_name} {name.last_name}" if name.last_name else name.first_name
            return f"@{sender_id} ({full_name})"
        return f"@{sender_id}"
    except Exception:
        return f"@{sender_id}"


async def get_chat_info(client, chat_id: int) -> str:
    """Получение информации о чате"""
    try:
        chat = await client.get_chat(chat_id)
        if chat:
            return f"«{chat.title}» ({chat_id})"
        return f"Chat {chat_id}"
    except Exception:
        return f"Chat {chat_id}"


async def process_attachments(client, message: Message):
    """Обработка вложений"""
    if not message.attaches:
        return

    sender_info = await get_sender_info(client, message.sender)
    chat_info = await get_chat_info(client, message.chat_id)

    for attach in message.attaches:
        try:
            if attach.type == AttachType.PHOTO:
                # Фото можно отправлять напрямую по URL
                caption = f"📸 Фото от {sender_info}\n💬 Чат: {chat_info}"
                send_photo_to_telegram(attach.base_url, caption)

            elif attach.type == AttachType.FILE:
                # Получаем URL для скачивания файла
                file_info = await client.get_file_by_id(
                    chat_id=message.chat_id,
                    message_id=message.id,
                    file_id=attach.file_id
                )

                if file_info and hasattr(file_info, 'url') and file_info.url:
                    caption = (
                        f"📎 Файл от {sender_info}\n"
                        f"💬 Чат: {chat_info}\n"
                        f"📁 {attach.name} ({getattr(attach, 'size', 'N/A')} байт)"
                    )
                    send_file_to_telegram(file_info.url, attach.name, caption)
                else:
                    logging.warning(f"Не удалось получить URL для файла {attach.name}")

            elif attach.type == AttachType.VIDEO:
                # Получаем URL для скачивания видео
                video_info = await client.get_video_by_id(
                    chat_id=message.chat_id,
                    message_id=message.id,
                    video_id=attach.video_id
                )

                if video_info and hasattr(video_info, 'url') and video_info.url:
                    caption = (
                        f"🎥 Видео от {sender_info}\n"
                        f"💬 Чат: {chat_info}\n"
                        f"⏱ {getattr(attach, 'duration', 'N/A')}с"
                    )
                    send_file_to_telegram(video_info.url, f"video_{attach.video_id}.mp4", caption)
                else:
                    logging.warning(f"Не удалось получить URL для видео {getattr(attach, 'video_id', 'N/A')}")

        except Exception as e:
            logging.error(f"Ошибка при обработке вложения {attach.type}: {e}")


@client.on_message()
async def forward_to_telegram(message: Message) -> None:
    """Пересылка сообщений и файлов в Telegram"""
    # Сначала обрабатываем вложения
    await process_attachments(client, message)

    # Затем отправляем текст (если есть)
    if message.text:
        sender_info = await get_sender_info(client, message.sender)
        chat_info = await get_chat_info(client, message.chat_id)

        telegram_text = (
            "📩 <b>Новое сообщение из Max</b>\n\n"
            f"👤 <b>Отправитель:</b> {sender_info}\n"
            f"💬 <b>Чат:</b> {chat_info}\n\n"
            f"📝 <b>Сообщение:</b>\n{message.text}"
        )

        # Отправляем в отдельном потоке
        threading.Thread(target=send_text_to_telegram, args=(telegram_text,)).start()


# Запуск Telegram бота в отдельном потоке
def start_telegram_bot():
    """Запуск Telegram бота для приема команд"""
    logging.info("Запуск Telegram бота...")
    tb.polling(none_stop=True)


if __name__ == "__main__":
    # Запускаем Telegram бота в фоновом потоке
    telegram_thread = threading.Thread(target=start_telegram_bot, daemon=True)
    telegram_thread.start()

    # Запускаем Max клиент
    asyncio.run(client.start())