Update app.py

app.py

@@ -5,7 +5,6 @@ import time
 import datetime
 import traceback
 import fractions
-import requests
 
 from fastapi import FastAPI, Request
 import av
@@ -15,9 +14,7 @@ app = FastAPI()
 # -------------------------------------------------------------------
 # Configuration & Global Variables
 # -------------------------------------------------------------------
-# (No external token or outgoing call configuration is required now.)
-# All functions will simply return JSON responses from the webhook endpoint.
-
+# (No token or outgoing calls are used in this version.)
 # Conversation state
 user_inputs = {}
 # The conversation fields will depend on the mode.
@@ -52,8 +49,9 @@ stream_thread = None
 live_log_thread = None
 
 # Live logging globals
-live_log_lines = []  # Rolling list (max 50 lines)
-live_log_message_id = None  # Dummy value used for simulation
+live_log_lines = []         # Rolling list (max 50 lines)
+live_log_display = ""       # Global variable updated every second by live_log_updater
+error_notification = ""     # Global variable to hold any error notification message
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -84,7 +82,7 @@ logger.addHandler(list_handler)
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    # Wrap text in <pre> tags for monospaced output (HTML parse mode)
+    # Wrap text in <pre> tags for monospaced output using HTML parse mode
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
@@ -130,8 +128,8 @@ def help_text():
     )
 
 def send_guide_message(chat_id, message):
+    # Return a response dictionary (to be sent as the webhook response)
     logging.info(f"Sending message to chat {chat_id}: {message}")
-    # Return a JSON response that would be sent back to Telegram via webhook.
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
@@ -159,41 +157,23 @@ def validate_inputs():
     return True, ""
 
 # -------------------------------------------------------------------
-# Notify Error Helper
+# Error Notification Helper
 # -------------------------------------------------------------------
 def notify_error(chat_id, error_message):
-    # Instead of making an outgoing call, simply return a JSON response
-    # (In practice, this error notification would be sent back via the webhook response.)
-    payload = {
-        "method": "sendMessage",
-        "chat_id": chat_id,
-        "text": f"⚠️ *Streaming Error Occurred:*\n\n{error_message}\n\nPlease check the live logs for details.",
-        "parse_mode": "Markdown"
-    }
-    logging.error(f"Notifying error to chat {chat_id}: {error_message}")
-    return payload
+    global error_notification
+    error_notification = error_message
+    # (This error will be available for the next webhook update; no outgoing call is made.)
+    logging.error(f"Error notified to user in chat {chat_id}: {error_message}")
 
 # -------------------------------------------------------------------
-# Live Logging Updater (Background Thread)
+# Live Log Updater (Background Thread)
 # -------------------------------------------------------------------
-def live_log_updater(chat_id):
-    global live_log_message_id, streaming_state
+def live_log_updater():
+    global live_log_display, streaming_state
     try:
-        # Simulate sending an initial live log message in HTML format
-        payload = {
-            "chat_id": chat_id,
-            "text": "<pre>Live Logs:\nInitializing...</pre>",
-            "parse_mode": "HTML"
-        }
-        # Since we are not making an outgoing call, simply log and assign a dummy message ID.
-        live_log_message_id = 1  # Dummy value for simulation
-        logging.info("Simulated live log message sent with dummy id 1")
-        # Update live log every 1 second until streaming stops
         while streaming_state in ["streaming", "paused"]:
-            # Prepare the log text from the last 15 log lines
-            log_text = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
-            # Instead of calling an external API, log the update that would be sent.
-            logging.info(f"Live log update for chat {chat_id}: {log_text}")
+            # Update the live log display variable with the last 15 log lines in HTML format
+            live_log_display = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
             time.sleep(1)
     except Exception as e:
         logging.error(f"Error in live log updater: {e}")
@@ -202,8 +182,12 @@ def live_log_updater(chat_id):
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    # Return the last 50 log lines in HTML format as a JSON response
+    # Return the last 50 log lines (if available) in HTML format
     log_text = "<pre>" + "\n".join(live_log_lines[-50:]) + "</pre>"
+    # If an error notification exists, prepend it to the log text.
+    global error_notification
+    if error_notification:
+        log_text = f"<pre>ERROR: {error_notification}\n\n" + log_text[5:]
     return {
          "method": "sendMessage",
          "chat_id": chat_id,
@@ -339,6 +323,13 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
 
         logging.info("Streaming started successfully.")
 
+        # Start the live log updater in a background thread
+        global live_log_thread
+        live_log_thread = threading.Thread(target=live_log_updater)
+        live_log_thread.daemon = True
+        live_log_thread.start()
+        logging.info("Live log updater thread started.")
+
         # Stream loop: process packets until state changes
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
@@ -388,11 +379,11 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
         error_message = f"An error occurred during streaming: {str(e)}\n\n{traceback.format_exc()}"
         logging.error(error_message)
         streaming_state = "idle"
-        # Notify the user about the error by returning a JSON response with the error details.
-        return notify_error(chat_id, error_message)
+        # Notify the user about the error by storing it in a global variable
+        notify_error(chat_id, error_message)
 
 def start_streaming(chat_id):
-    global stream_thread, live_log_thread, stream_chat_id
+    global stream_thread, stream_chat_id
     valid, msg = validate_inputs()
     if not valid:
         return send_guide_message(chat_id, f"Validation error: {msg}")
@@ -415,24 +406,20 @@ def start_streaming(chat_id):
         stream_thread.start()
         logging.info("Streaming thread started.")
 
-        # Start the live log updater thread (updates every 1 second in HTML format)
-        live_log_thread = threading.Thread(target=live_log_updater, args=(chat_id,))
-        live_log_thread.daemon = True
-        live_log_thread.start()
-        logging.info("Live log updater started.")
-
-        # Immediately inform the user that streaming has started
+        # Immediately inform the user that streaming has started;
+        # live log updates will be available via the global variable and /logs command.
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "🚀 *Streaming initiated!* Live logs are now updating below. Use the inline keyboard to control the stream.",
+            "text": "🚀 *Streaming initiated!* Live logs are now updating. Use the inline keyboard to control the stream.",
             "reply_markup": get_inline_keyboard_for_stream(),
             "parse_mode": "Markdown"
         }
     except Exception as e:
         error_message = f"Failed to start streaming: {str(e)}"
         logging.error(error_message)
-        return notify_error(chat_id, error_message)
+        notify_error(chat_id, error_message)
+        return send_guide_message(chat_id, error_message)
 
 # -------------------------------------------------------------------
 # Stream Control Handlers