Update app.py

app.py

@@ -16,9 +16,9 @@ app = FastAPI()
 # (No token or outgoing HTTP calls are used in this version.)
 # Conversation state
 user_inputs = {}
-# The conversation fields will depend on the mode.
-# Simple mode (default): Only "input_url" and "output_url" are required.
-# Advanced mode (if user sends /setting): Additional fields are required.
+# Conversation fields depend on the mode:
+# Simple mode (default): only "input_url" and "output_url" are required.
+# Advanced mode (if user sends /setting): additional fields are required.
 conversation_fields = []
 current_step = None
 advanced_mode = False
@@ -32,7 +32,7 @@ default_settings = {
 }
 
 # Streaming state & statistics
-streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
+streaming_state = "idle"  # Can be "idle", "streaming", "paused", or "stopped"
 stream_chat_id = None     # Chat ID for periodic updates
 stream_start_time = None
 frames_encoded = 0
@@ -48,9 +48,8 @@ stream_thread = None
 live_log_thread = None
 
 # Live logging globals
-live_log_lines = []     # Rolling list (max 50 log lines)
-live_log_display = ""   # Global variable updated every second by live_log_updater
-error_notification = "" # Global variable to hold error details if any
+live_log_lines = []     # A rolling list of log lines (max 50 lines)
+error_notification = "" # Holds error details (if any)
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -81,11 +80,11 @@ logger.addHandler(list_handler)
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    # Wrap text in <pre> tags for monospaced output using HTML parse mode
+    # Return an HTML-formatted message wrapped in <pre> tags for monospaced output.
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
-    # Inline keyboard for streaming controls that remain visible in the message
+    # Inline keyboard for stream controls; this keyboard is always returned along with status messages.
     keyboard = {
         "inline_keyboard": [
             [
@@ -101,7 +100,7 @@ def get_inline_keyboard_for_stream():
     return keyboard
 
 def get_inline_keyboard_for_start():
-    # Inline keyboard with a start button for when setup is complete.
+    # Inline keyboard with a "Start Streaming" button.
     keyboard = {
         "inline_keyboard": [
             [
@@ -127,7 +126,7 @@ def help_text():
     )
 
 def send_guide_message(chat_id, message):
-    # Returns a response dictionary (Markdown format) to be sent as the webhook reply
+    # Return a response dictionary (Markdown format) for webhook replies.
     logging.info(f"Sending message to chat {chat_id}: {message}")
     return {
         "method": "sendMessage",
@@ -137,7 +136,7 @@ def send_guide_message(chat_id, message):
     }
 
 def send_guide_message_html(chat_id, message):
-    # Returns a response dictionary (HTML format) to be sent as the webhook reply
+    # Return a response dictionary (HTML format) for webhook replies.
     logging.info(f"Sending HTML message to chat {chat_id}: {message}")
     return {
         "method": "sendMessage",
@@ -159,15 +158,14 @@ def get_uptime():
     return "0"
 
 def validate_inputs():
-    # Ensure all fields in conversation_fields have been provided
+    # Check that all required fields have been provided.
     missing = [field for field in conversation_fields if field not in user_inputs or not user_inputs[field]]
     if missing:
         return False, f"Missing fields: {', '.join(missing)}"
     return True, ""
 
 def get_streaming_display_message(prefix=""):
-    # Build an HTML message with a prefix, current streaming status, and live logs.
-    global live_log_display, streaming_state, frames_encoded, bytes_sent
+    # Build an HTML message that combines an optional prefix, current streaming status, and the last 15 log lines.
     status = (
         f"<b>Stream Status:</b>\n"
         f"State: {streaming_state}\n"
@@ -175,7 +173,14 @@ def get_streaming_display_message(prefix=""):
         f"Frames Encoded: {frames_encoded}\n"
         f"Bytes Sent: {bytes_sent}\n"
     )
-    logs = live_log_display if live_log_display else "<pre>No logs available yet.</pre>"
+    if live_log_lines:
+        logs = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
+    else:
+        logs = "<pre>No logs available yet.</pre>"
+    # Prepend any error notification if it exists.
+    global error_notification
+    if error_notification:
+        logs = f"<pre>ERROR: {error_notification}\n\n" + logs[5:]
     return f"{prefix}\n{status}\n\nLive Logs:\n{logs}"
 
 # -------------------------------------------------------------------
@@ -190,11 +195,11 @@ def notify_error(chat_id, error_message):
 # Live Log Updater (Background Thread)
 # -------------------------------------------------------------------
 def live_log_updater():
-    global live_log_display, streaming_state
+    # This thread continuously (every 1 second) updates the global log display.
     try:
-        while streaming_state in ["streaming", "paused"]:
-            # Update live_log_display with the last 15 log lines in HTML format
-            live_log_display = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
+        while True:
+            # (We no longer store the result in a separate variable;
+            # get_streaming_display_message computes the logs directly from live_log_lines.)
             time.sleep(1)
     except Exception as e:
         logging.error(f"Error in live log updater: {e}")
@@ -203,10 +208,13 @@ def live_log_updater():
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    global live_log_display, error_notification
-    # Use live_log_display if available; otherwise, show a default message.
-    log_text = live_log_display if live_log_display else "<pre>No logs available yet.</pre>"
-    # Prepend any error notification if present.
+    # Return a response containing the last 50 log lines (if any) in HTML format.
+    if live_log_lines:
+        log_text = "<pre>" + "\n".join(live_log_lines[-50:]) + "</pre>"
+    else:
+        log_text = "<pre>No logs available yet.</pre>"
+    # Prepend error notification if present.
+    global error_notification
     if error_notification:
         if log_text.startswith("<pre>"):
             log_text = f"<pre>ERROR: {error_notification}\n\n" + log_text[5:]
@@ -224,7 +232,7 @@ def logs_history(chat_id):
 # -------------------------------------------------------------------
 def handle_start(chat_id):
     global current_step, user_inputs, conversation_fields, advanced_mode
-    # Use simple mode by default (unless advanced_mode was set via /setting)
+    # Use simple mode by default (unless advanced_mode has been enabled)
     user_inputs = {}
     if not advanced_mode:
         conversation_fields = ["input_url", "output_url"]
@@ -337,14 +345,14 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
         out_audio_stream.layout = "stereo"
         video_stream.codec_context.time_base = fractions.Fraction(1, video_stream.rate)
         logging.info("Streaming started successfully.")
-        # Start live log updater if not already running
+        # Start live log updater (if not already running)
         global live_log_thread
         if live_log_thread is None or not live_log_thread.is_alive():
             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
+        # Streaming loop
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -484,8 +492,6 @@ def stream_status(chat_id):
 async def telegram_webhook(request: Request):
     update = await request.json()
     logging.debug(f"Received update: {update}")
-
-    # Process messages from users
     if "message" in update:
         chat_id = update["message"]["chat"]["id"]
         text = update["message"].get("text", "").strip()
@@ -507,13 +513,10 @@ async def telegram_webhook(request: Request):
             return stream_status(chat_id)
         else:
             return handle_conversation(chat_id, text)
-
-    # Process inline keyboard callback queries
     elif "callback_query" in update:
         callback_data = update["callback_query"]["data"]
         chat_id = update["callback_query"]["message"]["chat"]["id"]
         message_id = update["callback_query"]["message"]["message_id"]
-
         if callback_data == "pause":
             response = pause_stream(chat_id)
         elif callback_data == "resume":
@@ -526,10 +529,8 @@ async def telegram_webhook(request: Request):
             response = start_streaming(chat_id)
         else:
             response = send_guide_message_html(chat_id, "❓ Unknown callback command.")
-        # Update the original message while preserving inline keyboard
         response["method"] = "editMessageText"
         response["message_id"] = message_id
         response["reply_markup"] = get_inline_keyboard_for_stream()
         return response
-
     return {"status": "ok"}