Update app.py

app.py

@@ -5,7 +5,6 @@ import time
 import datetime
 import traceback
 import fractions
-import requests
 
 from fastapi import FastAPI, Request
 import av
@@ -15,17 +14,12 @@ app = FastAPI()
 # -------------------------------------------------------------------
 # Configuration & Global Variables
 # -------------------------------------------------------------------
-# We no longer use a global TELEGRAM_API_URL variable.
-# The bot token is obtained on demand via the helper function below.
-# TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
-# if not TELEGRAM_BOT_TOKEN:
-#     raise ValueError("Please set the TELEGRAM_BOT_TOKEN environment variable.")
-
+# (No explicit token usage here; all responses are returned as JSON.)
 # Conversation state
 user_inputs = {}
-# 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 depend on mode:
+# • Simple mode (default): Only "input_url" and "output_url" are required.
+# • Advanced mode (triggered by /setting): Additional fields are required.
 conversation_fields = []
 current_step = None
 advanced_mode = False
@@ -39,8 +33,8 @@ default_settings = {
 }
 
 # Streaming state & statistics
-streaming_state = "idle"  # "idle", "streaming", "paused", "stopped"
-stream_chat_id = None     # Chat ID for periodic updates
+streaming_state = "idle"  # Possible values: "idle", "streaming", "paused", "stopped"
+stream_chat_id = None     # Chat ID for the session
 stream_start_time = None
 frames_encoded = 0
 bytes_sent = 0
@@ -52,32 +46,9 @@ output_stream = None
 
 # Thread references
 stream_thread = None
-live_log_thread = None
-
-# Live logging globals
+# (No live log updater thread is launched because outgoing calls are not allowed.)
+# Instead, live logs are maintained in a global variable.
 live_log_lines = []  # Rolling list (max 50 lines)
-live_log_message_id = None
-
-# -------------------------------------------------------------------
-# Helper: Send Telegram API Request
-# -------------------------------------------------------------------
-def send_telegram_request(method: str, payload: dict):
-    """
-    Helper to send a request to the Telegram API.
-    """
-    bot_token = os.getenv("TELEGRAM_BOT_TOKEN")
-    if not bot_token:
-        logging.error("Missing TELEGRAM_BOT_TOKEN environment variable.")
-        return None
-    url = f"https://api.telegram.org/bot{bot_token}/{method}"
-    try:
-        response = requests.post(url, json=payload)
-        if not response.ok:
-            logging.error(f"Request to {url} failed with {response.text}")
-        return response
-    except Exception as e:
-        logging.error(f"Error sending request to Telegram: {e}")
-        return None
 
 # -------------------------------------------------------------------
 # Enhanced Logging Setup
@@ -108,12 +79,12 @@ logger.addHandler(list_handler)
 # Utility Functions & UI Helpers
 # -------------------------------------------------------------------
 def create_html_message(text: str):
-    # Wrap text in <pre> tags for monospaced output (HTML parse mode)
+    # Returns a response dict with HTML parse mode and wrapped in <pre> for monospaced output.
     return {"parse_mode": "HTML", "text": f"<pre>{text}</pre>"}
 
 def get_inline_keyboard_for_stream():
-    # Inline keyboard for streaming controls after the stream has started
-    keyboard = {
+    # Inline keyboard for controlling the stream.
+    return {
         "inline_keyboard": [
             [
                 {"text": "⏸ Pause", "callback_data": "pause"},
@@ -125,18 +96,16 @@ 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.
-    keyboard = {
+    # Inline keyboard with a single "Start Streaming" button.
+    return {
         "inline_keyboard": [
             [
                 {"text": "🚀 Start Streaming", "callback_data": "start_stream"}
             ]
         ]
     }
-    return keyboard
 
 def help_text():
     return (
@@ -175,63 +144,25 @@ def get_uptime():
     return "0"
 
 def validate_inputs():
-    # Ensure all fields in conversation_fields have been provided
+    # Ensure that every required field is 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, ""
 
 # -------------------------------------------------------------------
-# Notify Error Helper
+# Error Handling Helper
 # -------------------------------------------------------------------
 def notify_error(chat_id, error_message):
-    payload = {
-        "chat_id": chat_id,
-        "text": f"⚠️ *Streaming Error Occurred:*\n\n{error_message}\n\nPlease check the live logs for details.",
-        "parse_mode": "Markdown"
-    }
-    send_telegram_request("sendMessage", payload)
-
-# -------------------------------------------------------------------
-# Live Logging Updater (Background Thread)
-# -------------------------------------------------------------------
-def live_log_updater(chat_id):
-    global live_log_message_id, streaming_state
-    try:
-        # Send initial live log message in HTML format
-        payload = {
-            "chat_id": chat_id,
-            "text": "<pre>Live Logs:\nInitializing...</pre>",
-            "parse_mode": "HTML"
-        }
-        resp = send_telegram_request("sendMessage", payload)
-        if resp and resp.ok:
-            live_log_message_id = resp.json()["result"]["message_id"]
-            logging.info(f"Live log message sent with id {live_log_message_id}")
-        else:
-            logging.error("Failed to send live log message.")
-            return
-
-        # Update live log every 1 second until streaming stops
-        while streaming_state in ["streaming", "paused"]:
-            # Show the last 15 log lines in HTML format
-            log_text = "<pre>" + "\n".join(live_log_lines[-15:]) + "</pre>"
-            edit_payload = {
-                "chat_id": chat_id,
-                "message_id": live_log_message_id,
-                "text": log_text,
-                "parse_mode": "HTML"
-            }
-            send_telegram_request("editMessageText", edit_payload)
-            time.sleep(1)
-    except Exception as e:
-        logging.error(f"Error in live log updater: {e}")
+    # 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}")
 
 # -------------------------------------------------------------------
 # Logs History Handler (/logs)
 # -------------------------------------------------------------------
 def logs_history(chat_id):
-    # Show the last 50 log lines in HTML format
+    # Return the last 50 log lines in HTML format.
     log_text = "<pre>" + "\n".join(live_log_lines[-50:]) + "</pre>"
     return {
          "method": "sendMessage",
@@ -245,17 +176,18 @@ 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"]
     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",
@@ -270,8 +202,7 @@ 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 = "⚙️ *Advanced Mode Activated!*\n\nPlease enter the *input url*:"
     logging.info(f"/setting command from chat {chat_id} - advanced mode enabled")
     return {
         "method": "sendMessage",
@@ -292,14 +223,12 @@ 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]}")
         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]
@@ -308,17 +237,14 @@ 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,
@@ -338,17 +264,13 @@ 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
@@ -358,17 +280,11 @@ 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.")
-
-        # Stream loop: process packets until state changes
         while streaming_state in ["streaming", "paused"]:
             for packet in input_stream.demux():
                 if streaming_state == "stopped":
@@ -392,17 +308,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()
@@ -410,25 +321,21 @@ 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:
         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 using the live logs
         notify_error(chat_id, error_message)
 
 def start_streaming(chat_id):
-    global stream_thread, live_log_thread, stream_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}")
-
     stream_chat_id = chat_id
     try:
-        # Start the background streaming thread
         stream_thread = threading.Thread(
             target=stream_to_youtube,
             args=(
@@ -443,18 +350,10 @@ def start_streaming(chat_id):
         stream_thread.daemon = True
         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!* Live logs are now updating below. Use the inline keyboard to control the stream.",
+            "text": "🚀 *Streaming initiated!* Live logs are available via the /logs command. Use the inline keyboard to control the stream.",
             "reply_markup": get_inline_keyboard_for_stream(),
             "parse_mode": "Markdown"
         }
@@ -528,12 +427,9 @@ 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"):
@@ -551,15 +447,11 @@ 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":
@@ -572,10 +464,7 @@ async def telegram_webhook(request: Request):
             response = start_streaming(chat_id)
         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
-
     return {"status": "ok"}