Update app.py

app.py

@@ -12,12 +12,15 @@ import av
 app = FastAPI()
 
 # -------------------------------------------------------------------
-# Configuration & Global Variables
+# CONFIGURATION & GLOBAL VARIABLES
 # -------------------------------------------------------------------
-# (No outgoing HTTP calls or token usage in this version.)
-# Conversation state variables
+# (No token or outgoing HTTP calls are used in this version.)
+# Conversation state
 user_inputs = {}
-conversation_fields = []   # Depends on mode: simple vs. advanced
+# 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
 
@@ -30,8 +33,8 @@ default_settings = {
 }
 
 # Streaming state & statistics
-streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
-stream_chat_id = None     # Chat ID for updates
+streaming_state = "idle"  # Possible values: "idle", "streaming", "paused", "stopped"
+stream_chat_id = None     # Chat ID for periodic updates
 stream_start_time = None
 frames_encoded = 0
 bytes_sent = 0
@@ -45,13 +48,13 @@ output_stream = None
 stream_thread = None
 live_log_thread = None
 
-# Live logging globals
-live_log_lines = collections.deque(maxlen=50)  # Efficient log storage
-live_log_display = ""       # Global variable updated every second by live_log_updater
-error_notification = None   # Global variable to hold error details if any
+# Live logging globals using collections.deque for efficiency
+live_log_lines = collections.deque(maxlen=50)  # Efficient log storage (max 50 lines)
+live_log_display = ""   # Updated by the live log updater thread
+error_notification = "" # Holds error details if any error occurs
 
 # -------------------------------------------------------------------
-# Enhanced Logging Setup
+# ENHANCED LOGGING SETUP
 # -------------------------------------------------------------------
 logging.basicConfig(
     level=logging.DEBUG,
@@ -62,29 +65,30 @@ logger = logging.getLogger()
 logger.setLevel(logging.DEBUG)
 
 def append_live_log(line: str):
-    """Append a log line to the live log deque."""
+    """ Append a log line to the global deque. """
     live_log_lines.append(line)
 
 class ListHandler(logging.Handler):
-    """Custom logging handler to store logs for live display."""
+    """ Custom logging handler to store logs in the deque for live display. """
     def emit(self, record):
         log_entry = self.format(record)
         append_live_log(log_entry)
 
+# Attach custom logging handler
 list_handler = ListHandler()
 list_handler.setLevel(logging.DEBUG)
 list_handler.setFormatter(logging.Formatter("%Y-%m-%d %H:%M:%S [%(levelname)s] %(message)s"))
 logger.addHandler(list_handler)
 
 # -------------------------------------------------------------------
-# Utility Functions & UI Helpers
+# UTILITY FUNCTIONS & UI HELPERS
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    """Create an HTML-formatted message (using <pre> for monospaced text)."""
+    """ Returns a message dictionary with HTML formatting. """
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
-    """Return the inline keyboard for controlling the stream."""
+    """ Returns the inline keyboard for stream controls. """
     keyboard = {
         "inline_keyboard": [
             [
@@ -100,7 +104,7 @@ def get_inline_keyboard_for_stream():
     return keyboard
 
 def get_inline_keyboard_for_start():
-    """Return the inline keyboard with a Start Streaming button."""
+    """ Returns the inline keyboard with a Start Streaming button. """
     keyboard = {
         "inline_keyboard": [
             [
@@ -111,13 +115,13 @@ def get_inline_keyboard_for_start():
     return keyboard
 
 def help_text():
-    """Return help text for the bot."""
+    """ Returns the help text message. """
     return (
         "*Stream Bot Help*\n\n"
         "*/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 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 +131,7 @@ def help_text():
     )
 
 def send_guide_message(chat_id, message):
-    """Return a response dictionary to send a guide message."""
+    """ Returns a response dictionary for sending a guide message. """
     logging.info(f"Sending message to chat {chat_id}: {message}")
     return {
         "method": "sendMessage",
@@ -137,56 +141,58 @@ def send_guide_message(chat_id, message):
     }
 
 def reset_statistics():
-    """Reset the streaming statistics."""
+    """ Resets streaming statistics. """
     global stream_start_time, frames_encoded, bytes_sent
     stream_start_time = datetime.datetime.now()
     frames_encoded = 0
     bytes_sent = 0
 
 def get_uptime():
-    """Return the current uptime as a string."""
+    """ Returns the uptime as a formatted string. """
     if stream_start_time:
         uptime = datetime.datetime.now() - stream_start_time
         return str(uptime).split('.')[0]
     return "0"
 
 def validate_inputs():
-    """Ensure all required fields have been provided."""
+    """ Validates that all required 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 Notification Helper
+# ERROR NOTIFICATION VIA GLOBAL VARIABLE
 # -------------------------------------------------------------------
 def notify_error(chat_id, error_message):
-    """Store the error message globally and log it."""
+    """ Stores the error message in a global variable and logs it. """
     global error_notification
     error_notification = error_message
-    logger.error(f"Error for chat {chat_id}: {error_message}")
+    logging.error(f"Error for chat {chat_id}: {error_message}")
 
 # -------------------------------------------------------------------
-# Live Log Updater Thread
+# LIVE LOG UPDATER THREAD
 # -------------------------------------------------------------------
 def live_log_updater():
-    """Continuously update the global live_log_display variable while streaming is active."""
+    """ Continuously updates the global live_log_display with the latest log lines. """
     global live_log_display, streaming_state
     try:
         while streaming_state in ["streaming", "paused"]:
+            # Update with all lines from the deque, joined by newlines
             live_log_display = "<pre>" + "\n".join(list(live_log_lines)) + "</pre>"
             time.sleep(1)
     except Exception as e:
-        logger.exception("Error in live log updater")
+        logging.exception("Error in live log updater")
 
 # -------------------------------------------------------------------
-# Logs History Handler (/logs)
+# LOGS HISTORY HANDLER (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    """Return the live log display (including error notification if any) as HTML."""
+    """ Returns the current live log display, prepending any error notification if present. """
     global live_log_display, error_notification
     log_text = live_log_display if live_log_display else "<pre>No logs available yet.</pre>"
     if error_notification:
+        # Prepend the error message to the log display
         if log_text.startswith("<pre>"):
             log_text = f"<pre>ERROR: {error_notification}\n\n" + log_text[5:]
         else:
@@ -199,21 +205,24 @@ def logs_history(chat_id):
     }
 
 # -------------------------------------------------------------------
-# Conversation Handlers
+# CONVERSATION HANDLERS
 # -------------------------------------------------------------------
 def handle_start(chat_id):
     global current_step, user_inputs, conversation_fields, advanced_mode
+    # Default to simple mode unless /setting has been issued
     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]})_'}:")
-    logger.info(f"/start command from chat {chat_id} (advanced_mode={advanced_mode})")
+    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",
         "chat_id": chat_id,
@@ -227,9 +236,11 @@ 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*:")
-    logger.info(f"/setting command from chat {chat_id} - advanced mode enabled")
+    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,
@@ -238,7 +249,7 @@ def handle_setting(chat_id):
     }
 
 def handle_help(chat_id):
-    logger.info(f"/help command from chat {chat_id}")
+    logging.info(f"/help command from chat {chat_id}")
     return {
         "method": "sendMessage",
         "chat_id": chat_id,
@@ -251,10 +262,10 @@ def handle_conversation(chat_id, text):
     if current_step:
         if text.strip() == "" and current_step in default_settings:
             user_inputs[current_step] = default_settings[current_step]
-            logger.info(f"Using default for {current_step}: {default_settings[current_step]}")
+            logging.info(f"Using default for {current_step}: {default_settings[current_step]}")
         else:
             user_inputs[current_step] = text.strip()
-            logger.info(f"Received {current_step}: {text.strip()}")
+            logging.info(f"Received {current_step}: {text.strip()}")
 
         idx = conversation_fields.index(current_step)
         if idx < len(conversation_fields) - 1:
@@ -283,11 +294,11 @@ def handle_conversation(chat_id, text):
         return send_guide_message(chat_id, "Unrecognized input. Type /help for available commands.")
 
 # -------------------------------------------------------------------
-# Background Streaming Functions
+# BACKGROUND STREAMING FUNCTIONS
 # -------------------------------------------------------------------
 def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, output_url, chat_id):
     global video_stream, audio_stream_in, output_stream, streaming_state, frames_encoded, bytes_sent
-    logger.info("Initiating streaming to YouTube")
+    logging.info("Initiating streaming to YouTube")
     try:
         streaming_state = "streaming"
         reset_statistics()
@@ -319,15 +330,16 @@ def stream_to_youtube(input_url, quality_settings, video_codec, audio_codec, out
 
         video_stream.codec_context.time_base = fractions.Fraction(1, video_stream.rate)
 
-        logger.info("Streaming started successfully.")
+        logging.info("Streaming started successfully.")
 
         # Start live log updater 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, daemon=True)
             live_log_thread.start()
-            logger.info("Live log updater thread started.")
+            logging.info("Live log updater thread started.")
 
+        # Main streaming loop
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -352,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 any remaining packets
             for out_packet in video_stream.encode():
                 output_stream.mux(out_packet)
             for out_packet in out_audio_stream.encode():
@@ -360,19 +373,20 @@ 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()
             output_stream.close()
             input_stream.close()
         except Exception as cleanup_error:
-            logger.error(f"Error during cleanup: {cleanup_error}")
+            logging.error(f"Error during cleanup: {cleanup_error}")
 
-        logger.info("Streaming complete, resources cleaned up.")
+        logging.info("Streaming complete, resources cleaned up.")
         streaming_state = "idle"
     except Exception as e:
         error_message = f"An error occurred during streaming: {str(e)}\n\n{traceback.format_exc()}"
-        logger.error(error_message)
+        logging.error(error_message)
         streaming_state = "idle"
         notify_error(chat_id, error_message)
 
@@ -393,11 +407,12 @@ def start_streaming(chat_id):
                 user_inputs["audio_codec"],
                 user_inputs["output_url"],
                 chat_id,
-            ),
-            daemon=True
+            )
         )
+        stream_thread.daemon = True
         stream_thread.start()
-        logger.info("Streaming thread started.")
+        logging.info("Streaming thread started.")
+
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
@@ -407,18 +422,18 @@ def start_streaming(chat_id):
         }
     except Exception as e:
         error_message = f"Failed to start streaming: {str(e)}"
-        logger.error(error_message)
+        logging.error(error_message)
         notify_error(chat_id, error_message)
         return send_guide_message(chat_id, error_message)
 
 # -------------------------------------------------------------------
-# Stream Control Handlers
+# STREAM CONTROL HANDLERS
 # -------------------------------------------------------------------
 def pause_stream(chat_id):
     global streaming_state
     if streaming_state == "streaming":
         streaming_state = "paused"
-        logger.info("Streaming paused.")
+        logging.info("Streaming paused.")
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
@@ -431,7 +446,7 @@ def resume_stream(chat_id):
     global streaming_state
     if streaming_state == "paused":
         streaming_state = "streaming"
-        logger.info("Streaming resumed.")
+        logging.info("Streaming resumed.")
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
@@ -444,7 +459,7 @@ def abort_stream(chat_id):
     global streaming_state
     if streaming_state in ["streaming", "paused"]:
         streaming_state = "stopped"
-        logger.info("Streaming aborted by user.")
+        logging.info("Streaming aborted by user.")
         return {
             "method": "sendMessage",
             "chat_id": chat_id,
@@ -469,12 +484,12 @@ def stream_status(chat_id):
     }
 
 # -------------------------------------------------------------------
-# FastAPI Webhook Endpoint for Telegram Updates
+# FASTAPI WEBHOOK ENDPOINT FOR TELEGRAM UPDATES
 # -------------------------------------------------------------------
 @app.post("/webhook")
 async def telegram_webhook(request: Request):
     update = await request.json()
-    logger.debug(f"Received update: {update}")
+    logging.debug(f"Received update: {update}")
 
     # Process messages from users
     if "message" in update: