Update app.py

app.py

@@ -85,7 +85,7 @@ def create_html_message(text: str):
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
-    # Inline keyboard for streaming controls (when streaming is active)
+    # Inline keyboard for streaming controls that remain visible in the message
     keyboard = {
         "inline_keyboard": [
             [
@@ -101,7 +101,7 @@ def get_inline_keyboard_for_stream():
     return keyboard
 
 def get_inline_keyboard_for_start():
-    # Inline keyboard with a start button (when inputs are complete)
+    # Inline keyboard with a start button for when setup is complete.
     keyboard = {
         "inline_keyboard": [
             [
@@ -117,7 +117,7 @@ def help_text():
         "*/start* - Begin setup for streaming (simple mode: only Input & Output URL)\n"
         "*/setting* - Enter advanced settings (Input URL, Quality Settings, Video Codec, Audio Codec, Output URL)\n"
         "*/help* - Display this help text\n"
-        "*/logs* - Show the live log history\n\n"
+        "*/logs* - Show the log history (live log display)\n\n"
         "After inputs are collected, press the inline *Start Streaming* button.\n\n"
         "While streaming, you can use inline buttons or commands:\n"
         "*/pause* - Pause the stream\n"
@@ -127,7 +127,7 @@ def help_text():
     )
 
 def send_guide_message(chat_id, message):
-    # Return a response dictionary to be sent as the webhook reply
+    # 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,6 +136,16 @@ def send_guide_message(chat_id, message):
         "parse_mode": "Markdown"
     }
 
+def send_guide_message_html(chat_id, message):
+    # 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",
+        "chat_id": chat_id,
+        "text": message,
+        "parse_mode": "HTML"
+    }
+
 def reset_statistics():
     global stream_start_time, frames_encoded, bytes_sent
     stream_start_time = datetime.datetime.now()
@@ -155,6 +165,19 @@ def validate_inputs():
         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
+    status = (
+        f"<b>Stream Status:</b>\n"
+        f"State: {streaming_state}\n"
+        f"Uptime: {get_uptime()}\n"
+        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>"
+    return f"{prefix}\n{status}\n\nLive Logs:\n{logs}"
+
 # -------------------------------------------------------------------
 # Error Notification Helper
 # -------------------------------------------------------------------
@@ -170,9 +193,8 @@ def live_log_updater():
     global live_log_display, streaming_state
     try:
         while streaming_state in ["streaming", "paused"]:
-            # Include a header with the current update time in the log display.
-            current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            live_log_display = f"<pre>Live Logs (Updated at {current_time}):\n" + "\n".join(live_log_lines[-15:]) + "</pre>"
+            # Update 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:
         logging.error(f"Error in live log updater: {e}")
@@ -182,9 +204,9 @@ def live_log_updater():
 # -------------------------------------------------------------------
 def logs_history(chat_id):
     global live_log_display, error_notification
-    # Use the global live_log_display; if empty, show a default message.
+    # 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>"
-    # If an error occurred, prepend the error notification.
+    # 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:]
@@ -202,23 +224,25 @@ def logs_history(chat_id):
 # -------------------------------------------------------------------
 def handle_start(chat_id):
     global current_step, user_inputs, conversation_fields, advanced_mode
-    # By default, simple mode is used unless advanced_mode is set via /setting.
+    # Use simple mode by default (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 = ("👋 *Welcome to the Stream Bot!*\n\n"
-            "Let's set up your stream.\n"
-            f"Please enter the *{current_step.replace('_', ' ')}*"
-            f"{' (no default)' if current_step not in default_settings else f' _(default: {default_settings[current_step]})_'}:")
+    text = (
+        "👋 <b>Welcome to the Stream Bot!</b>\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]})'}:"
+    )
     logging.info(f"/start command from chat {chat_id} (advanced_mode={advanced_mode})")
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
         "text": text,
-        "parse_mode": "Markdown"
+        "parse_mode": "HTML"
     }
 
 def handle_setting(chat_id):
@@ -227,14 +251,16 @@ 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 = ("⚙️ *Advanced Mode Activated!*\n\n"
-            "Please enter the *input url*:")
+    text = (
+        "⚙️ <b>Advanced Mode Activated!</b>\n\n"
+        "Please enter the <b>input url</b>:"
+    )
     logging.info(f"/setting command from chat {chat_id} - advanced mode enabled")
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
         "text": text,
-        "parse_mode": "Markdown"
+        "parse_mode": "HTML"
     }
 
 def handle_help(chat_id):
@@ -249,7 +275,6 @@ def handle_help(chat_id):
 def handle_conversation(chat_id, text):
     global current_step, user_inputs, conversation_fields
     if current_step:
-        # If the response is empty and a default exists, use the default.
         if text.strip() == "" and current_step in default_settings:
             user_inputs[current_step] = default_settings[current_step]
             logging.info(f"Using default for {current_step}: {default_settings[current_step]}")
@@ -259,31 +284,28 @@ def handle_conversation(chat_id, text):
         idx = conversation_fields.index(current_step)
         if idx < len(conversation_fields) - 1:
             current_step = conversation_fields[idx + 1]
-            prompt = f"Please enter the *{current_step.replace('_', ' ')}*"
+            prompt = f"Please enter the <b>{current_step.replace('_', ' ')}</b>"
             if current_step in default_settings:
-                prompt += f" _(default: {default_settings[current_step]})_"
-            return send_guide_message(chat_id, prompt)
+                prompt += f" (default: {default_settings[current_step]})"
+            return send_guide_message_html(chat_id, prompt)
         else:
-            # All inputs have been collected.
             current_step = None
             valid, msg = validate_inputs()
             if not valid:
-                return send_guide_message(chat_id, f"Validation error: {msg}")
-            # In simple mode, fill in advanced fields with defaults.
+                return send_guide_message_html(chat_id, f"Validation error: {msg}")
             if not advanced_mode:
                 user_inputs.setdefault("quality_settings", default_settings["quality_settings"])
                 user_inputs.setdefault("video_codec", default_settings["video_codec"])
                 user_inputs.setdefault("audio_codec", default_settings["audio_codec"])
-            # Instead of asking the user to type "start", send an inline button.
             return {
                 "method": "sendMessage",
                 "chat_id": chat_id,
-                "text": "All inputs received. Press *🚀 Start Streaming* to begin.\n\n" + live_log_display,
+                "text": "All inputs received. Press <b>🚀 Start Streaming</b> to begin.",
                 "reply_markup": get_inline_keyboard_for_start(),
-                "parse_mode": "Markdown"
+                "parse_mode": "HTML"
             }
     else:
-        return send_guide_message(chat_id, "Unrecognized input. Type /help for available commands.")
+        return send_guide_message_html(chat_id, "Unrecognized input. Type /help for available commands.")
 
 # -------------------------------------------------------------------
 # Background Streaming Functions
@@ -296,7 +318,6 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
         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
@@ -311,20 +332,19 @@ 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 the live log updater in a background thread 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: process packets until state changes
+        # Stream loop
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -348,14 +368,12 @@ 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()
@@ -369,14 +387,13 @@ 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 storing it in a global variable
         notify_error(chat_id, error_message)
 
 def start_streaming(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}")
+        return send_guide_message_html(chat_id, f"Validation error: {msg}")
     stream_chat_id = chat_id
     try:
         stream_thread = threading.Thread(
@@ -393,20 +410,18 @@ def start_streaming(chat_id):
         stream_thread.daemon = True
         stream_thread.start()
         logging.info("Streaming thread started.")
-        # Immediately inform the user that streaming has started, along with current live logs.
-        response_text = "🚀 *Streaming initiated!* Live logs are now updating below:\n\n" + live_log_display
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": response_text,
+            "text": get_streaming_display_message("<b>Streaming initiated!</b>"),
             "reply_markup": get_inline_keyboard_for_stream(),
-            "parse_mode": "Markdown"
+            "parse_mode": "HTML"
         }
     except Exception as e:
         error_message = f"Failed to start streaming: {str(e)}"
         logging.error(error_message)
         notify_error(chat_id, error_message)
-        return send_guide_message(chat_id, error_message)
+        return send_guide_message_html(chat_id, error_message)
 
 # -------------------------------------------------------------------
 # Stream Control Handlers
@@ -419,10 +434,11 @@ def pause_stream(chat_id):
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "⏸ *Streaming paused.*",
-            "parse_mode": "Markdown"
+            "text": get_streaming_display_message("<b>Streaming paused.</b>"),
+            "reply_markup": get_inline_keyboard_for_stream(),
+            "parse_mode": "HTML"
         }
-    return send_guide_message(chat_id, "Streaming is not active.")
+    return send_guide_message_html(chat_id, "Streaming is not active.")
 
 def resume_stream(chat_id):
     global streaming_state
@@ -432,10 +448,11 @@ def resume_stream(chat_id):
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "▶️ *Streaming resumed.*",
-            "parse_mode": "Markdown"
+            "text": get_streaming_display_message("<b>Streaming resumed.</b>"),
+            "reply_markup": get_inline_keyboard_for_stream(),
+            "parse_mode": "HTML"
         }
-    return send_guide_message(chat_id, "Streaming is not paused.")
+    return send_guide_message_html(chat_id, "Streaming is not paused.")
 
 def abort_stream(chat_id):
     global streaming_state
@@ -445,24 +462,19 @@ def abort_stream(chat_id):
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "⏹ *Streaming aborted.*",
-            "parse_mode": "Markdown"
+            "text": get_streaming_display_message("<b>Streaming aborted.</b>"),
+            "reply_markup": get_inline_keyboard_for_stream(),
+            "parse_mode": "HTML"
         }
-    return send_guide_message(chat_id, "No active streaming to abort.")
+    return send_guide_message_html(chat_id, "No active streaming to abort.")
 
 def stream_status(chat_id):
-    stats = (
-        f"*Stream Status:*\n\n"
-        f"• **State:** {streaming_state}\n"
-        f"• **Uptime:** {get_uptime()}\n"
-        f"• **Frames Encoded:** {frames_encoded}\n"
-        f"• **Bytes Sent:** {bytes_sent}\n"
-    )
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
-        "text": stats,
-        "parse_mode": "Markdown"
+        "text": get_streaming_display_message("<b>Current streaming status:</b>"),
+        "reply_markup": get_inline_keyboard_for_stream(),
+        "parse_mode": "HTML"
     }
 
 # -------------------------------------------------------------------
@@ -494,13 +506,14 @@ async def telegram_webhook(request: Request):
         elif text.startswith("/status"):
             return stream_status(chat_id)
         else:
-            # Process conversation setup inputs
             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,13 +525,11 @@ async def telegram_webhook(request: Request):
         elif callback_data == "start_stream":
             response = start_streaming(chat_id)
         else:
-            response = send_guide_message(chat_id, "❓ Unknown callback command.")
-        # Ensure the inline keyboard remains in the updated message.
-        if streaming_state in ["streaming", "paused"]:
-            response["reply_markup"] = get_inline_keyboard_for_stream()
-        elif current_step is None:
-            response["reply_markup"] = get_inline_keyboard_for_start()
+            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"}