Update app.py

app.py

@@ -49,7 +49,7 @@ 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()
+live_log_display = ""   # Global variable updated every second by live_log_updater
 error_notification = "" # Global variable to hold error details if any
 
 # -------------------------------------------------------------------
@@ -77,6 +77,17 @@ list_handler = ListHandler()
 list_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s", "%Y-%m-%d %H:%M:%S"))
 logger.addHandler(list_handler)
 
+# -------------------------------------------------------------------
+# Helper Function: Compose Streaming Message
+# -------------------------------------------------------------------
+def compose_streaming_message():
+    global live_log_display, error_notification
+    msg = ""
+    if error_notification:
+        msg += "<b>ERROR:</b> " + error_notification + "\n\n"
+    msg += "🚀 <b>Streaming in progress!</b>\n\nLive Logs:\n" + live_log_display + "\n\nUse the inline keyboard to control the stream."
+    return msg
+
 # -------------------------------------------------------------------
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
@@ -155,17 +166,6 @@ def validate_inputs():
         return False, f"Missing fields: {', '.join(missing)}"
     return True, ""
 
-# -------------------------------------------------------------------
-# Helper to Compose the Streaming Message (HTML)
-# -------------------------------------------------------------------
-def compose_streaming_message():
-    global live_log_display, error_notification
-    msg = ""
-    if error_notification:
-        msg += "<b>ERROR:</b> " + error_notification + "\n\n"
-    msg += "🚀 <b>Streaming in progress!</b>\n\nLive Logs:\n" + live_log_display + "\n\nUse the inline keyboard to control the stream."
-    return msg
-
 # -------------------------------------------------------------------
 # Error Notification Helper
 # -------------------------------------------------------------------
@@ -181,7 +181,7 @@ def live_log_updater():
     global live_log_display, streaming_state
     try:
         while streaming_state in ["streaming", "paused"]:
-            # Update live_log_display with the last 15 log lines (HTML formatted)
+            # Update the global live_log_display 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:
@@ -210,23 +210,23 @@ def logs_history(chat_id):
 # -------------------------------------------------------------------
 def handle_start(chat_id):
     global current_step, user_inputs, conversation_fields, advanced_mode
-    # Use simple mode unless advanced_mode is set via /setting
+    # By default, use simple mode (unless advanced_mode was set via /setting)
     user_inputs = {}
     if not advanced_mode:
         conversation_fields = ["input_url", "output_url"]
     else:
         conversation_fields = ["input_url", "quality_settings", "video_codec", "audio_codec", "output_url"]
     current_step = conversation_fields[0]
-    text = ("👋 <b>Welcome to the Stream Bot!</b>\n\n"
+    text = ("👋 *Welcome to the Stream Bot!*\n\n"
             "Let's set up your stream.\n"
-            f"Please enter the <b>{current_step.replace('_', ' ')}</b>"
-            f"{' (no default)' if current_step not in default_settings else f' (default: {default_settings[current_step]})'}:")
+            f"Please enter the *{current_step.replace('_', ' ')}*"
+            f"{' (no default)' if current_step not in default_settings else f' _(default: {default_settings[current_step]})_'}:")
     logging.info(f"/start command from chat {chat_id} (advanced_mode={advanced_mode})")
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
         "text": text,
-        "parse_mode": "HTML"
+        "parse_mode": "Markdown"
     }
 
 def handle_setting(chat_id):
@@ -235,14 +235,14 @@ def handle_setting(chat_id):
     conversation_fields = ["input_url", "quality_settings", "video_codec", "audio_codec", "output_url"]
     user_inputs = {}
     current_step = conversation_fields[0]
-    text = ("⚙️ <b>Advanced Mode Activated!</b>\n\n"
-            "Please enter the <b>input url</b>:")
+    text = ("⚙️ *Advanced Mode Activated!*\n\n"
+            "Please enter the *input url*:")
     logging.info(f"/setting command from chat {chat_id} - advanced mode enabled")
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
         "text": text,
-        "parse_mode": "HTML"
+        "parse_mode": "Markdown"
     }
 
 def handle_help(chat_id):
@@ -263,18 +263,14 @@ def handle_conversation(chat_id, text):
         else:
             user_inputs[current_step] = text.strip()
             logging.info(f"Received {current_step}: {text.strip()}")
+
         idx = conversation_fields.index(current_step)
         if idx < len(conversation_fields) - 1:
             current_step = conversation_fields[idx + 1]
-            prompt = f"Please enter the <b>{current_step.replace('_', ' ')}</b>"
+            prompt = f"Please enter the *{current_step.replace('_', ' ')}*"
             if current_step in default_settings:
-                prompt += f" (default: {default_settings[current_step]})"
-            return {
-                "method": "sendMessage",
-                "chat_id": chat_id,
-                "text": prompt,
-                "parse_mode": "HTML"
-            }
+                prompt += f" _(default: {default_settings[current_step]})_"
+            return send_guide_message(chat_id, prompt)
         else:
             current_step = None
             valid, msg = validate_inputs()
@@ -287,9 +283,9 @@ def handle_conversation(chat_id, text):
             return {
                 "method": "sendMessage",
                 "chat_id": chat_id,
-                "text": "All inputs received. Press <b>🚀 Start Streaming</b> to begin.",
+                "text": "All inputs received. Press *🚀 Start Streaming* to begin.",
                 "reply_markup": get_inline_keyboard_for_start(),
-                "parse_mode": "HTML"
+                "parse_mode": "Markdown"
             }
     else:
         return send_guide_message(chat_id, "Unrecognized input. Type /help for available commands.")
@@ -303,13 +299,17 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
     try:
         streaming_state = "streaming"
         reset_statistics()
+
         input_stream = av.open(input_url)
         output_stream = av.open(output_url, mode='w', format='flv')
+
+        # Configure video stream
         video_stream = output_stream.add_stream(video_codec, rate=30)
         video_stream.width = input_stream.streams.video[0].width
         video_stream.height = input_stream.streams.video[0].height
         video_stream.pix_fmt = input_stream.streams.video[0].format.name
         video_stream.codec_context.options.update({'g': '30'})
+
         if quality_settings.lower() == "high":
             video_stream.bit_rate = 3000000
             video_stream.bit_rate_tolerance = 1000000
@@ -319,18 +319,25 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
         elif quality_settings.lower() == "low":
             video_stream.bit_rate = 800000
             video_stream.bit_rate_tolerance = 200000
+
+        # Configure audio stream
         audio_stream_in = input_stream.streams.audio[0]
         out_audio_stream = output_stream.add_stream(audio_codec, rate=audio_stream_in.rate)
         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 thread if not already running
+
+        # Start the live log updater in a background thread 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: process packets until state changes
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -354,12 +361,17 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
                             output_stream.mux(out_packet)
                             if hasattr(out_packet, "size"):
                                 bytes_sent += out_packet.size
+
+            # Flush remaining packets
             for out_packet in video_stream.encode():
                 output_stream.mux(out_packet)
             for out_packet in out_audio_stream.encode():
                 output_stream.mux(out_packet)
+
             if streaming_state == "paused":
                 time.sleep(1)
+
+        # Clean up resources
         try:
             video_stream.close()
             out_audio_stream.close()
@@ -367,6 +379,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
             input_stream.close()
         except Exception as cleanup_error:
             logging.error(f"Error during cleanup: {cleanup_error}")
+
         logging.info("Streaming complete, resources cleaned up.")
         streaming_state = "idle"
     except Exception as e:
@@ -380,6 +393,7 @@ def start_streaming(chat_id):
     valid, msg = validate_inputs()
     if not valid:
         return send_guide_message(chat_id, f"Validation error: {msg}")
+
     stream_chat_id = chat_id
     try:
         stream_thread = threading.Thread(
@@ -396,6 +410,7 @@ def start_streaming(chat_id):
         stream_thread.daemon = True
         stream_thread.start()
         logging.info("Streaming thread started.")
+        # Immediately return a message that includes the live log display via compose_streaming_message()
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
@@ -420,7 +435,7 @@ def pause_stream(chat_id):
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "⏸ <b>Streaming paused.</b>\n\n" + compose_streaming_message(),
+            "text": "⏸ <b>Streaming paused.</b>",
             "parse_mode": "HTML"
         }
     return send_guide_message(chat_id, "Streaming is not active.")
@@ -433,7 +448,7 @@ def resume_stream(chat_id):
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "▶️ <b>Streaming resumed.</b>\n\n" + compose_streaming_message(),
+            "text": "▶️ <b>Streaming resumed.</b>",
             "parse_mode": "HTML"
         }
     return send_guide_message(chat_id, "Streaming is not paused.")
@@ -473,10 +488,12 @@ 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()
+
         if text.startswith("/setting"):
             return handle_setting(chat_id)
         elif text.startswith("/start"):
@@ -495,11 +512,13 @@ 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":
@@ -512,12 +531,16 @@ async def telegram_webhook(request: Request):
             response = start_streaming(chat_id)
         else:
             response = send_guide_message(chat_id, "❓ Unknown callback command.")
+
+        # For streaming control callbacks, update the message with the latest live logs
         if callback_data in ["pause", "resume", "abort", "status", "start_stream"]:
             response["method"] = "editMessageText"
             response["message_id"] = message_id
             response["text"] = compose_streaming_message()
             response["parse_mode"] = "HTML"
+            # Always include the inline keyboard if streaming is active.
             if streaming_state in ["streaming", "paused"]:
                 response["reply_markup"] = get_inline_keyboard_for_stream()
         return response
+
     return {"status": "ok"}