Update main.py

main.py

@@ -1,45 +1,24 @@
-import os
-from collections import deque
-
-from flask import Flask, request
 import telegram
 from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters
 import schedule
 import time
-from threading import Thread
+import os
+from collections import deque
 from asyncio import run
 
 BOT_TOKEN = os.environ['YOUR_BOT_TOKEN']
 YOUR_USER_ID = 855890735  # Замените на ваш ID
 CHANNEL_ID = os.environ['YOUR_CHANNEL_ID']  # Замените на ID канала
 
+# Создаем бота Telegram
 bot = telegram.Bot(token=BOT_TOKEN)
+
 application = ApplicationBuilder().token(BOT_TOKEN).build()
+
 message_queue = deque()
 test_mode = False
 
 
-# --- Flask app ---
-app = Flask(__name__)
-
-
-@app.route('/', methods=['GET'])
-def home():
-    return "Это API сервер для Telegram бота."
-
-
-@app.route('/send_message', methods=['POST'])
-def send_message():
-    data = request.get_json()
-    message = data.get('message')
-    if message:
-        message_queue.append(message)
-        return {'status': 'ok'}
-    else:
-        return {'status': 'error', 'message': 'Missing message data'}
-
-
-# --- Telegram bot handlers ---
 async def handle_message(update, context):
     message = update.message
     if message and message.from_user:
@@ -47,16 +26,24 @@ async def handle_message(update, context):
         if user_id == YOUR_USER_ID and message.chat.type == 'private':
             if not message.text.startswith("/"):
                 if test_mode:
-                    await forward_message(message.text)
-                    print(f"Сообщение '{message.text}' отправлено напрямую (тестовый режим).")
+                    await forward_message(message.message_id)
+                    print(
+                        f"Сообщение с ID {message.message_id} отправлено напрямую (тестовый режим)."
+                    )
                 else:
-                    message_queue.append(message.text)
-                    print(f"Добавлено сообщение '{message.text}' в очередь.")
+                    message_queue.append(message.message_id)
+                    print(
+                        f"Добавлено сообщение с ID {message.message_id} в очередь."
+                    )
             else:
                 print(f"Получена команда от владельца: {message.text}")
         else:
-            print(f"Получено сообщение от постороннего пользователя (ID: {user_id}): {message.text}")
-            await update.message.reply_text("Извини, но я могу общаться только с моим владельцем.")
+            print(
+                f"Получено сообщение от постороннего пользователя (ID: {user_id}): {message.text}"
+            )
+            await update.message.reply_text(
+                "Извини, но я могу общаться только с моим владельцем."
+            )
 
 
 async def start(update, context):
@@ -65,8 +52,12 @@ async def start(update, context):
         print("Владелец начал диалог.")
         await update.message.reply_text("Привет!")
     else:
-        print(f"Посторонний пользователь (ID: {user_id}) попытался начать диалог.")
-        await update.message.reply_text("Извини, но я могу общаться только с моим владельцем.")
+        print(
+            f"Посторонний пользователь (ID: {user_id}) попытался начать диалог."
+        )
+        await update.message.reply_text(
+            "Извини, но я могу общаться только с моим владельцем."
+        )
 
 
 async def clear_queue(update, context):
@@ -90,64 +81,50 @@ async def send_now(update, context):
     global message_queue
     if update.effective_user.id == YOUR_USER_ID:
         if message_queue:
-            message = message_queue.popleft()
-            await forward_message(message)
-            message_queue.append(message)  # Переносим в конец очереди
+            message_id = message_queue.popleft()
+            await forward_message(message_id)
+            message_queue.append(message_id)  # Переносим в конец очереди
             print("Отправлено первое сообщение из очереди.")
             await update.message.reply_text("Отправлено первое сообщение из очереди.")
         else:
             print("Очередь пуста.")
             await update.message.reply_text("Очередь пуста.")
 
-
 async def delete_last_message(update, context):
     global message_queue
     if update.effective_user.id == YOUR_USER_ID:
         if message_queue:
-            deleted_message = message_queue.pop()
-            print(f"Удалено сообщение '{deleted_message}' из очереди.")
+            deleted_message_id = message_queue.pop()
+            print(f"Удалено сообщение с ID {deleted_message_id} из очереди.")
             await update.message.reply_text("Последнее сообщение удалено из очереди.")
         else:
             print("Очередь пуста, нечего удалять.")
             await update.message.reply_text("Очередь пуста, нечего удалять.")
 
 
-async def forward_message(message):
+async def forward_message(message_id):
     try:
-        await bot.send_message(chat_id=CHANNEL_ID, text=message)
-        print(f"Сообщение '{message}' успешно отправлено в канал.")
+        await bot.copy_message(
+            chat_id=CHANNEL_ID, from_chat_id=YOUR_USER_ID, message_id=message_id
+        )
+        print(f"Сообщение с ID {message_id} успешно отправлено в канал.")
     except telegram.error.BadRequest as e:
-        print(f"Ошибка при отправке сообщения: {e}")
+        print(f"Ошибка при копировании сообщения: {e}")
 
 
-# --- Планировщик ---
-def send_messages_from_queue():
+def send_messages():
     global message_queue
     if message_queue:
-        message = message_queue.popleft()
-        run(forward_message(message))
+        message_id = message_queue.popleft()
+        # Запускаем асинхронную функцию в отдельном потоке
+        run(forward_message(message_id))
 
 
-schedule.every().day.at("00:00").do(send_messages_from_queue)
-schedule.every().day.at("04:00").do(send_messages_from_queue)
-schedule.every().day.at("08:00").do(send_messages_from_queue)
-schedule.every().day.at("12:00").do(send_messages_from_queue)
-schedule.every().day.at("16:00").do(send_messages_from_queue)
-schedule.every().day.at("20:00").do(send_messages_from_queue)
-
-
-def run_scheduler():
-    while True:
-        schedule.run_pending()
-        time.sleep(1)
-
-
-# --- Регистрация обработчиков Telegram ---
 start_handler = CommandHandler("start", start)
 clear_handler = CommandHandler("clear", clear_queue)
 test_handler = CommandHandler("test", toggle_test_mode)
-send_now_handler = CommandHandler("send", send_now)
-delete_last_handler = CommandHandler("del", delete_last_message)
+send_now_handler = CommandHandler("send", send_now) 
+delete_last_handler = CommandHandler("del", delete_last_message) 
 message_handler = MessageHandler(
     filters=filters.TEXT & ~filters.COMMAND, callback=handle_message
 )
@@ -155,27 +132,33 @@ message_handler = MessageHandler(
 application.add_handler(start_handler)
 application.add_handler(clear_handler)
 application.add_handler(test_handler)
-application.add_handler(send_now_handler)
-application.add_handler(delete_last_handler)
+application.add_handler(send_now_handler)  
+application.add_handler(delete_last_handler)  
 application.add_handler(message_handler)
 
-
-# --- Обработчик ошибок Telegram ---
+# Добавляем обработчик ошибок
 async def error_handler(update, context):
     """Обработчик ошибок."""
     print(f'Произошла ошибка: {context.error}')
-
-
 application.add_error_handler(error_handler)
 
+# Запускаем планировщик в отдельном потоке
+schedule.every().day.at("00:00").do(send_messages)
+schedule.every().day.at("04:00").do(send_messages)
+schedule.every().day.at("08:00").do(send_messages)
+schedule.every().day.at("12:00").do(send_messages)
+schedule.every().day.at("16:00").do(send_messages)
+schedule.every().day.at("20:00").do(send_messages)
 
-# --- Запуск приложения ---
-if __name__ == "__main__":
-    scheduler_thread = Thread(target=run_scheduler)
-    scheduler_thread.start()
+from threading import Thread
 
-    flask_thread = Thread(target=app.run, kwargs={'host': '0.0.0.0', 'port': 5000})
-    flask_thread.start()
+def run_scheduler():
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
 
-    application.run_polling()
+scheduler_thread = Thread(target=run_scheduler)
+scheduler_thread.start()
 
+# Запускаем бота в главном потоке
+application.run_polling()