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 = {}
-# 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.
+# 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 = []
 current_step = None
 advanced_mode = False
@@ -32,7 +32,7 @@ default_settings = {
 }
 
 # Streaming state & statistics
-streaming_state = "idle"  # Can be "idle", "streaming", "paused", or "stopped"
+streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
 stream_chat_id = None     # Chat ID for periodic updates
 stream_start_time = None
 frames_encoded = 0
@@ -48,8 +48,9 @@ stream_thread = None
 live_log_thread = None
 
 # Live logging globals
-live_log_lines = []     # A rolling list of log lines (max 50 lines)
-error_notification = "" # Holds error details (if any)
+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
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -80,11 +81,11 @@ logger.addHandler(list_handler)
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    # Return an HTML-formatted message wrapped in <pre> tags for monospaced output.
+    # 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():
-    # Inline keyboard for stream controls; this keyboard is always returned along with status messages.
+    # Inline keyboard for streaming controls that remain visible in the message
     keyboard = {
         "inline_keyboard": [
             [
@@ -100,7 +101,7 @@ def get_inline_keyboard_for_stream():
     return keyboard
 
 def get_inline_keyboard_for_start():
-    # Inline keyboard with a "Start Streaming" button.
+    # Inline keyboard with a start button for when setup is complete.
     keyboard = {
         "inline_keyboard": [
             [
@@ -126,7 +127,7 @@ def help_text():
     )
 
 def send_guide_message(chat_id, message):
-    # Return a response dictionary (Markdown format) for webhook replies.
+    # Returns a response dictionary (Markdown format) to be sent as the webhook reply
     logging.info(f"Sending message to chat {chat_id}: {message}")
     return {
         "method": "sendMessage",
@@ -136,7 +137,7 @@ def send_guide_message(chat_id, message):
     }
 
 def send_guide_message_html(chat_id, message):
-    # Return a response dictionary (HTML format) for webhook replies.
+    # Returns a response dictionary (HTML format) to be sent as the webhook reply
     logging.info(f"Sending HTML message to chat {chat_id}: {message}")
     return {
         "method": "sendMessage",
@@ -158,14 +159,15 @@ def get_uptime():
     return "0"
 
 def validate_inputs():
-    # Check that all required fields have been provided.
+    # Ensure all fields in conversation_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 that combines an optional prefix, current streaming status, and the last 15 log lines.
+    # Build an HTML message with a prefix, current streaming status, and live logs.
+    global live_log_display, streaming_state, frames_encoded, bytes_sent
     status = (
         f"<b>Stream Status:</b>\n"
         f"State: {streaming_state}\n"
@@ -173,14 +175,7 @@ def get_streaming_display_message(prefix=""):
         f"Frames Encoded: {frames_encoded}\n"
         f"Bytes Sent: {bytes_sent}\n"
     )
-    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:]
+    logs = live_log_display if live_log_display.strip() != "" else "<pre>No logs available yet.</pre>"
     return f"{prefix}\n{status}\n\nLive Logs:\n{logs}"
 
 # -------------------------------------------------------------------
@@ -195,12 +190,14 @@ def notify_error(chat_id, error_message):
 # Live Log Updater (Background Thread)
 # -------------------------------------------------------------------
 def live_log_updater():
-    # This thread continuously (every 1 second) updates the global log display.
+    global live_log_display, streaming_state
     try:
         while True:
-            # (We no longer store the result in a separate variable;
-            # get_streaming_display_message computes the logs directly from live_log_lines.)
+            live_log_display = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
             time.sleep(1)
+            # If streaming has ended, break out after updating one last time.
+            if streaming_state == "idle":
+                break
     except Exception as e:
         logging.error(f"Error in live log updater: {e}")
 
@@ -208,13 +205,10 @@ def live_log_updater():
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    # 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
+    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.strip() != "" else "<pre>No logs available yet.</pre>"
+    # Prepend any error notification if present.
     if error_notification:
         if log_text.startswith("<pre>"):
             log_text = f"<pre>ERROR: {error_notification}\n\n" + log_text[5:]
@@ -232,7 +226,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 has been enabled)
+    # Use simple mode by default (unless advanced_mode was set via /setting)
     user_inputs = {}
     if not advanced_mode:
         conversation_fields = ["input_url", "output_url"]
@@ -345,14 +339,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)
+        # Add an initial log entry so live_log_display is not empty.
+        logging.info("Live log updating has begun.")
         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.")
-        # Streaming loop
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":