Update app.py

app.py

@@ -14,12 +14,13 @@ app = FastAPI()
 # -------------------------------------------------------------------
 # Configuration & Global Variables
 # -------------------------------------------------------------------
-# (No explicit token usage here; all responses are returned as JSON.)
+# (The bot token is assumed to be configured externally via the webhook URL.)
+# No token is used in any outgoing call functions.
 # Conversation state
 user_inputs = {}
-# Conversation fields depend on mode:
-# • Simple mode (default): Only "input_url" and "output_url" are required.
-# • Advanced mode (triggered by /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
@@ -33,8 +34,8 @@ default_settings = {
 }
 
 # Streaming state & statistics
-streaming_state = "idle"  # Possible values: "idle", "streaming", "paused", "stopped"
-stream_chat_id = None     # Chat ID for the session
+streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
+stream_chat_id = None     # Chat ID for responses
 stream_start_time = None
 frames_encoded = 0
 bytes_sent = 0
@@ -44,11 +45,9 @@ video_stream = None
 audio_stream_in = None
 output_stream = None
 
-# Thread references
-stream_thread = None
-# (No live log updater thread is launched because outgoing calls are not allowed.)
-# Instead, live logs are maintained in a global variable.
+# Live logging globals
 live_log_lines = []  # Rolling list (max 50 lines)
+last_error_notification = None  # Stores error messages (if any)
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -79,11 +78,11 @@ logger.addHandler(list_handler)
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    # Returns a response dict with HTML parse mode and wrapped in <pre> for monospaced output.
+    # Wrap text in <pre> tags for monospaced output (HTML parse mode)
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
-    # Inline keyboard for controlling the stream.
+    # Inline keyboard for streaming controls after the stream has started
     return {
         "inline_keyboard": [
             [
@@ -98,7 +97,7 @@ def get_inline_keyboard_for_stream():
     }
 
 def get_inline_keyboard_for_start():
-    # Inline keyboard with a single "Start Streaming" button.
+    # Inline keyboard with a start button for when conversation is complete.
     return {
         "inline_keyboard": [
             [
@@ -144,30 +143,35 @@ def get_uptime():
     return "0"
 
 def validate_inputs():
-    # Ensure that every required field is 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, ""
 
 # -------------------------------------------------------------------
-# Error Handling Helper
+# Error Notification Helper
 # -------------------------------------------------------------------
 def notify_error(chat_id, error_message):
-    # Instead of making an outgoing call, we simply log the error.
-    # The error will appear in the global log history (and can be retrieved via /logs).
-    logging.error(f"Notify user (chat {chat_id}) about error: {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).
 
 # -------------------------------------------------------------------
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    # Return the last 50 log lines in HTML format.
-    log_text = "<pre>" + "\n".join(live_log_lines[-50:]) + "</pre>"
+    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 {
          "method": "sendMessage",
          "chat_id": chat_id,
-         "text": log_text,
+         "text": f"<pre>{log_text}</pre>",
          "parse_mode": "HTML"
     }
 
@@ -176,6 +180,7 @@ def logs_history(chat_id):
 # -------------------------------------------------------------------
 def handle_start(chat_id):
     global current_step, user_inputs, conversation_fields, advanced_mode
+    # By default, simple mode (unless advanced_mode was set via /setting)
     user_inputs = {}
     if not advanced_mode:
         conversation_fields = ["input_url", "output_url"]
@@ -229,6 +234,7 @@ 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]
@@ -264,13 +270,16 @@ 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')
+
         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
@@ -280,11 +289,15 @@ 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
+
         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.")
+
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -308,12 +321,15 @@ 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
+
             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)
+
         try:
             video_stream.close()
             out_audio_stream.close()
@@ -321,6 +337,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:
@@ -350,10 +367,11 @@ def start_streaming(chat_id):
         stream_thread.daemon = True
         stream_thread.start()
         logging.info("Streaming thread started.")
+
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
-            "text": "🚀 *Streaming initiated!* Live logs are available via the /logs command. Use the inline keyboard to control the stream.",
+            "text": "🚀 *Streaming initiated!* Use the inline keyboard to control the stream. (Use /logs to view live log history.)",
             "reply_markup": get_inline_keyboard_for_stream(),
             "parse_mode": "Markdown"
         }
@@ -427,9 +445,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"):
@@ -448,10 +469,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":
@@ -464,7 +488,9 @@ async def telegram_webhook(request: Request):
             response = start_streaming(chat_id)
         else:
             response = send_guide_message(chat_id, "❓ Unknown callback command.")
+
         response["method"] = "editMessageText"
         response["message_id"] = message_id
         return response
+
     return {"status": "ok"}