Update app.py

app.py

@@ -5,6 +5,7 @@ import time
 import datetime
 import traceback
 import fractions
+import requests
 
 from fastapi import FastAPI, Request
 import av
@@ -14,8 +15,9 @@ app = FastAPI()
 # -------------------------------------------------------------------
 # Configuration & Global Variables
 # -------------------------------------------------------------------
-# (The bot token is assumed to be configured externally via the webhook URL.)
-# No token is used in any outgoing call functions.
+# (No external token or outgoing call configuration is required now.)
+# All functions will simply return JSON responses from the webhook endpoint.
+
 # Conversation state
 user_inputs = {}
 # The conversation fields will depend on the mode.
@@ -35,7 +37,7 @@ default_settings = {
 
 # Streaming state & statistics
 streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
-stream_chat_id = None     # Chat ID for responses
+stream_chat_id = None     # Chat ID for periodic updates
 stream_start_time = None
 frames_encoded = 0
 bytes_sent = 0
@@ -45,9 +47,13 @@ video_stream = None
 audio_stream_in = None
 output_stream = None
 
+# Thread references
+stream_thread = None
+live_log_thread = None
+
 # Live logging globals
 live_log_lines = []  # Rolling list (max 50 lines)
-last_error_notification = None  # Stores error messages (if any)
+live_log_message_id = None  # Dummy value used for simulation
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -83,7 +89,7 @@ def create_html_message(text: str):
 
 def get_inline_keyboard_for_stream():
     # Inline keyboard for streaming controls after the stream has started
-    return {
+    keyboard = {
         "inline_keyboard": [
             [
                 {"text": "⏸ Pause", "callback_data": "pause"},
@@ -95,16 +101,18 @@ def get_inline_keyboard_for_stream():
             ]
         ]
     }
+    return keyboard
 
 def get_inline_keyboard_for_start():
     # Inline keyboard with a start button for when conversation is complete.
-    return {
+    keyboard = {
         "inline_keyboard": [
             [
                 {"text": "🚀 Start Streaming", "callback_data": "start_stream"}
             ]
         ]
     }
+    return keyboard
 
 def help_text():
     return (
@@ -123,6 +131,7 @@ def help_text():
 
 def send_guide_message(chat_id, message):
     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,
@@ -150,28 +159,55 @@ def validate_inputs():
     return True, ""
 
 # -------------------------------------------------------------------
-# Error Notification Helper
+# Notify Error Helper
 # -------------------------------------------------------------------
 def notify_error(chat_id, error_message):
-    global last_error_notification
-    last_error_notification = error_message
-    logging.error(f"Notifying user (chat {chat_id}) of error: {error_message}")
-    # Because we are not making outgoing calls, this error message will be delivered
-    # when the user next sends a command (e.g. /logs or /status).
+    # 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
+
+# -------------------------------------------------------------------
+# Live Logging Updater (Background Thread)
+# -------------------------------------------------------------------
+def live_log_updater(chat_id):
+    global live_log_message_id, 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}")
+            time.sleep(1)
+    except Exception as e:
+        logging.error(f"Error in live log updater: {e}")
 
 # -------------------------------------------------------------------
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    global last_error_notification
-    log_text = ""
-    if last_error_notification:
-        log_text += "⚠️ *Error Notification:*\n" + last_error_notification + "\n\n"
-    log_text += "\n".join(live_log_lines[-50:])
+    # Return the last 50 log lines in HTML format as a JSON response
+    log_text = "<pre>" + "\n".join(live_log_lines[-50:]) + "</pre>"
     return {
          "method": "sendMessage",
          "chat_id": chat_id,
-         "text": f"<pre>{log_text}</pre>",
+         "text": log_text,
          "parse_mode": "HTML"
     }
 
@@ -187,12 +223,10 @@ def handle_start(chat_id):
     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 = ("👋 *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]})_'}:")
     logging.info(f"/start command from chat {chat_id} (advanced_mode={advanced_mode})")
     return {
         "method": "sendMessage",
@@ -207,7 +241,8 @@ 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\nPlease enter the *input url*:"
+    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",
@@ -228,6 +263,7 @@ 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]}")
@@ -243,14 +279,17 @@ def handle_conversation(chat_id, text):
                 prompt += f" _(default: {default_settings[current_step]})_"
             return send_guide_message(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.
             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,
@@ -274,6 +313,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
         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
@@ -290,6 +330,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
             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"
@@ -298,6 +339,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
 
         logging.info("Streaming started successfully.")
 
+        # Stream loop: process packets until state changes
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -322,6 +364,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
                             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():
@@ -330,6 +373,7 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
             if streaming_state == "paused":
                 time.sleep(1)
 
+        # Clean up resources
         try:
             video_stream.close()
             out_audio_stream.close()
@@ -344,15 +388,18 @@ 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_error(chat_id, error_message)
+        # Notify the user about the error by returning a JSON response with the error details.
+        return notify_error(chat_id, error_message)
 
 def start_streaming(chat_id):
-    global stream_thread, stream_chat_id
+    global stream_thread, live_log_thread, stream_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:
+        # Start the background streaming thread
         stream_thread = threading.Thread(
             target=stream_to_youtube,
             args=(
@@ -368,18 +415,24 @@ 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
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "🚀 *Streaming initiated!* Use the inline keyboard to control the stream. (Use /logs to view live log history.)",
+            "text": "🚀 *Streaming initiated!* Live logs are now updating below. 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)
-        notify_error(chat_id, error_message)
-        return send_guide_message(chat_id, error_message)
+        return notify_error(chat_id, error_message)
 
 # -------------------------------------------------------------------
 # Stream Control Handlers
@@ -468,6 +521,7 @@ 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
@@ -489,6 +543,7 @@ async def telegram_webhook(request: Request):
         else:
             response = send_guide_message(chat_id, "❓ Unknown callback command.")
 
+        # Edit the original message with updated information
         response["method"] = "editMessageText"
         response["message_id"] = message_id
         return response