app.py

import logging
import os
import requests
import sys
import aiogram
import random
import asyncio
from typing import List
from requests.exceptions import ConnectionError

from aiogram import Bot, Dispatcher, F, types
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.types import ContentType, Message
from aiogram_media_group import MediaGroupFilter, media_group_handler
from dotenv import load_dotenv
from vk_api import VkApi
from vk_api.upload import VkUpload
from vk_api.utils import get_random_id
from PIL import Image, UnidentifiedImageError
from rlottie_python import LottieAnimation
from moviepy.editor import VideoFileClip

load_dotenv()
logging.basicConfig(level=logging.INFO)

TELEGRAM_API_TOKEN = os.getenv('TELEGRAM_API_TOKEN')
TELEGRAM_CHANNEL_USERNAME = os.getenv('TELEGRAM_CHANNEL_USERNAME')
VK_API_TOKEN = os.getenv('VK_API_TOKEN')
VK_GROUP_ID = os.getenv('VK_GROUP_ID')

vk_session = VkApi(token=VK_API_TOKEN)
vk = vk_session.get_api()
uploader = VkUpload(vk)
PROXY_URL = os.getenv('PROXY_URL')
proxy = PROXY_URL
proxies = {"http": proxy, "https": proxy}

bot = Bot(token=TELEGRAM_API_TOKEN, proxy=proxies)
storage = MemoryStorage()

dp = Dispatcher(storage=storage, proxy=proxies)

def add_entry(message_id, post_id):
    with open('data.txt', 'a') as f:
        f.write(f'{message_id}:{post_id}\n')


def get_entry(message_id) -> int:
    with open('data.txt', 'r') as f:
        for line in f.readlines():
            if int(line.split(':')[0]) == message_id:
                return int(line.split(':')[1])
        raise KeyError(f'{message_id} is not in the file!')


def create_vk_post(text: str, message_id, photo_list=None, video_list=None, doc_list=None, audio_list=None, gif_list=None):
    photos, videos, docs, audios, gifs = [], [], [], [], []

    try:
        if photo_list:
            photos = uploader.photo_wall(photos=photo_list, group_id=VK_GROUP_ID)
        if video_list:
            videos = [uploader.video(video_file=path, group_id=int(VK_GROUP_ID)) for path in video_list]
        if doc_list:
            for doc in doc_list:
                if os.path.exists(doc):
                    with open(doc, 'rb') as f:
                        doc_info = uploader.document(doc=f, title=os.path.basename(doc))
                        docs.append(doc_info)
        if audio_list:
            for audio in audio_list:
                if os.path.exists(audio):
                    with open(audio, 'rb') as f:
                        audio_info = uploader.audio(audio=f, artist="Unknown Artist", title=os.path.basename(audio))
                        audios.append(audio_info)
        if gif_list:
            for gif in gif_list:
                if os.path.exists(gif):
                    with open(gif, 'rb') as f:
                        gif_info = uploader.document(doc=f, title=os.path.basename(gif))
                        gifs.append(gif_info)

        attachments = [f'photo{photo.get("owner_id")}_{photo["id"]}' for photo in photos if "owner_id" in photo and "id" in photo]
        attachments += [f'video{video["owner_id"]}_{video["video_id"]}' for video in videos if "owner_id" in video and "video_id" in video]
        attachments += [f'doc{doc["doc"]["owner_id"]}_{doc["doc"]["id"]}' for doc in docs if "doc" in doc and "owner_id" in doc["doc"] and "id" in doc["doc"]]
        attachments += [f'audio{audio["owner_id"]}_{audio["id"]}' for audio in audios if "owner_id" in audio and "id" in audio]
        attachments += [f'doc{gif["doc"]["owner_id"]}_{gif["doc"]["id"]}' for gif in gifs if "doc" in gif and "owner_id" in gif["doc"] and "id" in gif["doc"]]

        source_link = f'https://t.me/{TELEGRAM_CHANNEL_USERNAME}/{message_id}'
        post_text = f'{text}\n\nИсточник: {source_link}'

        response = vk.wall.post(
            owner_id=f'-{VK_GROUP_ID}',
            message=post_text,
            attachments=','.join(attachments),
            from_group=1,
            copyright=source_link,
            random_id=get_random_id()
        )
        post_id = response['post_id']
        add_entry(message_id, post_id)

    except Exception as e:
        logging.error(f'Error while creating VK post: {e}')


def edit_vk_post(post_id, new_text, message_id):
    old_post = vk.wall.getById(posts=f'-{VK_GROUP_ID}_{post_id}')[0]
    attachments = [f'{attachment["type"]}{attachment[attachment["type"]]["owner_id"]}_{attachment[attachment["type"]]["id"]}' for attachment in old_post.get('attachments', [])]

    source_link = f'https://t.me/{TELEGRAM_CHANNEL_USERNAME}/{message_id}'
    edited_text = f'{new_text}\n\nИсточник: {source_link}'

    vk.wall.edit(
        message=edited_text,
        post_id=post_id,
        from_group=1,
        owner_id=f'-{VK_GROUP_ID}',
        copyright=source_link,
        attachments=attachments
    )


async def download_file_with_retries(file_id: str, destination: str, retries: int = 3, delay: int = 5):
    os.makedirs(os.path.dirname(destination), exist_ok=True)
    for attempt in range(retries):
        try:
            file = await bot.get_file(file_id)
            await bot.download_file(file.file_path, destination)
            return True
        except Exception as e:
            logging.error(f'Error while downloading file (attempt {attempt + 1}/{retries}): {e}')
            if attempt < retries - 1:
                await asyncio.sleep(delay)
    return False


@media_group_handler
async def album_handler(messages: List[Message]):
    random_number = random.randint(1000000, 9999999)
    c = 0

    photo_list = []
    video_list = []
    doc_list = []
    audio_list = []
    gif_list = []
    text = None

    for message in messages:
        if message.caption and not text:
            text = message.caption
        if message.photo:
            path = f'./files/photo_{random_number}_{c}.jpg'
            if await download_file_with_retries(message.photo[-1].file_id, path):
                photo_list.append(path)
        elif message.video:
            path = f'./files/video_{random_number}_{c}.mp4'
            if await download_file_with_retries(message.video.file_id, path):
                video_list.append(path)
        elif message.document:
            path = f'./files/doc_{random_number}_{c}_{message.document.file_name}'
            if await download_file_with_retries(message.document.file_id, path):
                doc_list.append(path)
        elif message.audio:
            path = f'./files/audio_{random_number}_{c}_{message.audio.file_name}'
            if await download_file_with_retries(message.audio.file_id, path):
                audio_list.append(path)
        elif message.animation:
            path = f'./files/gif_{random_number}_{c}.mp4'
            if await download_file_with_retries(message.animation.file_id, path):
                gif_list.append(path)
        c += 1

    message_id = messages[0].message_id
    post_text = text if text else ''
    await asyncio.to_thread(create_vk_post, post_text, message_id, photo_list, video_list, doc_list, audio_list, gif_list)
    
    for path in photo_list + video_list + doc_list + audio_list + gif_list:
        os.remove(path)


async def photo_video_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    if message.photo:
        path = f'./files/photo_{random_number}.jpg'
        if await download_file_with_retries(message.photo[-1].file_id, path):
            await asyncio.to_thread(create_vk_post, text, message.message_id, [path])
            os.remove(path)
    elif message.video:
        path = f'./files/video_{random_number}.mp4'
        if await download_file_with_retries(message.video.file_id, path):
            await asyncio.to_thread(create_vk_post, text, message.message_id, None, [path])
            os.remove(path)


async def document_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    path = f'./files/doc_{random_number}_{message.document.file_name}'
    if await download_file_with_retries(message.document.file_id, path):
        await asyncio.to_thread(create_vk_post, text, message.message_id, None, None, [path])
        os.remove(path)


async def audio_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    audio_paths = []
    for i, audio in enumerate(message.audio):
        path = f'./files/audio_{random_number}_{i}_{audio.file_name}'
        if await download_file_with_retries(audio.file_id, path):
            if os.path.exists(path):
                audio_paths.append(path)
    if audio_paths:
        await asyncio.to_thread(create_vk_post, text, message.message_id, None, None, None, audio_paths)
        for path in audio_paths:
            os.remove(path)


async def video_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    path = f'./files/video_{random_number}_{message.video.file_name}'
    if await download_file_with_retries(message.video.file_id, path):
        if os.path.exists(path):
            await asyncio.to_thread(create_vk_post, text, message.message_id, None, [path])
            os.remove(path)


async def text_handler(message: Message):
    await asyncio.to_thread(create_vk_post, message.text, message.message_id)


async def edited_handler(message: Message):
    if message.message_id is None:
        return

    try:
        post_id = get_entry(message.message_id)
    except KeyError:
        return

    text = message.text or message.caption or ''
    await asyncio.to_thread(edit_vk_post, post_id, text, message.message_id)


async def sticker_handler(message: Message):
    random_number = random.randint(1000000, 9999999)
    path = f'./files/sticker_{random_number}.{"tgs" if message.sticker.is_animated else "webp"}'
    if await download_file_with_retries(message.sticker.file_id, path):
        if message.sticker.is_animated or message.sticker.is_video:
            try:
                gif_path = f'./files/sticker_{random_number}.gif'

                if message.sticker.is_animated:
                    animation = LottieAnimation.from_tgs(path)
                    frames = [animation.render_pillow_frame(frame_num=i) for i in range(animation.lottie_animation_get_totalframe())]
                    frames[0].save(gif_path, save_all=True, append_images=frames[1:], loop=0, duration=1000 // animation.lottie_animation_get_framerate())
                else:
                    clip = VideoFileClip(path)
                    clip.write_gif(gif_path)
                    clip.close()

                os.remove(path)
                await asyncio.to_thread(create_vk_post, '', message.message_id, None, None, None, None, [gif_path])
                os.remove(gif_path)
            except Exception as e:
                logging.error(f'Error while converting animated sticker: {e}')
                try:
                    os.remove(path)
                except PermissionError:
                    pass
        else:
            try:
                png_path = f'./files/sticker_{random_number}.png'
                try:
                    with Image.open(path) as im:
                        width, height = im.size
                        scale = 1.0
                        width_new, height_new = int(width * scale), int(height * scale)
                        im_resized = im.resize((width_new, height_new), Image.LANCZOS)
                        im_resized.save(png_path, 'PNG')
                except UnidentifiedImageError as e:
                    raise
                os.remove(path)
                await asyncio.to_thread(create_vk_post, '', message.message_id, [png_path], None, None, None, None)
                os.remove(png_path)
            except Exception as e:
                logging.error(f'Error while converting static sticker: {e}')
                if os.path.exists(path):
                    os.remove(path)


async def voice_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    path = f'./files/voice_{random_number}.ogg'

    download_task = asyncio.create_task(download_file_with_retries(message.voice.file_id, path, retries=5, delay=10))

    try:
        await download_task
        if not os.path.exists(path):
            return
    except Exception as e:
        return

    file_size = os.path.getsize(path)
    max_size = 10 * 1024 * 1024
    if file_size > max_size:
        os.remove(path)
        return

    await asyncio.to_thread(create_vk_post, text, message.message_id, None, None, None, [path])
    os.remove(path)


async def animation_handler(message: Message):
    text = message.caption or ''
    random_number = random.randint(1000000, 9999999)
    path = f'./files/animation_{random_number}.mp4'
    retries = 3
    delay = 5
    for attempt in range(retries):
        try:
            if await download_file_with_retries(message.animation.file_id, path):
                gif_path = f'./files/animation_{random_number}.gif'
                clip = VideoFileClip(path)
                clip.write_gif(gif_path)
                clip.close()
                os.remove(path)
                await asyncio.to_thread(create_vk_post, text, message.message_id, None, None, None, None, [gif_path])
                os.remove(gif_path)
                break
        except Exception as e:
            if attempt < retries - 1:
                await asyncio.sleep(delay)
            else:
                logging.error(f'Failed to download animation {message.animation.file_id} after {retries} attempts')

async def main():
    dp.channel_post.register(album_handler, MediaGroupFilter())
    dp.channel_post.register(photo_video_handler, F.content_type.in_([ContentType.PHOTO, ContentType.VIDEO]))
    dp.channel_post.register(document_handler, F.content_type == ContentType.DOCUMENT)
    dp.channel_post.register(audio_handler, F.content_type == ContentType.AUDIO)
    dp.channel_post.register(video_handler, F.content_type == ContentType.VIDEO)
    dp.channel_post.register(text_handler, F.content_type == ContentType.TEXT)
    dp.channel_post.register(sticker_handler, F.content_type == ContentType.STICKER)
    dp.channel_post.register(animation_handler, F.content_type == ContentType.ANIMATION)
    dp.channel_post.register(voice_handler, F.content_type == ContentType.VOICE)
    dp.edited_channel_post.register(edited_handler)

    await dp.start_polling(bot)

if __name__ == '__main__':
    logging.info('Starting bot')
    asyncio.run(main())