Update app.py

app.py

@@ -33,6 +33,7 @@ API_ID = int(os.environ.get("API_ID", 0))
 API_HASH = os.environ.get("API_HASH")     
 SUPABASE_URL = os.environ.get("SUPABASE_URL")
 SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+BYSE_API_KEY = os.environ.get("BYSE_API_KEY", "133323knboif885fhgwxvf")
 
 PREMIUM_CHANNEL_ID = -1002825744390
 STORAGE_CHANNEL_ID = -1002825744390  # যে চ্যানেলে ভিডিও স্টোর হবে
@@ -49,6 +50,9 @@ supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 admin_states = {}
 temp_clients = {}
 
+# ডিফল্ট আপলোড সার্ভার মোড (Telegram)
+upload_mode = "telegram"
+
 try:
     main_loop = asyncio.get_running_loop()
 except RuntimeError:
@@ -553,6 +557,25 @@ async def start_cloning(client, message):
 
 # =================================================================
 
+# ================= NEW: SET UPLOAD SERVER MODE =================
+@bot.on_message(filters.command("upload") & filters.private & filters.user(ADMIN_IDS))
+async def set_upload_mode(client, message):
+    global upload_mode
+    args = message.command
+    if len(args) > 1:
+        mode = args[1].lower()
+        if mode in ["telegram", "tg", "local"]:
+            upload_mode = "telegram"
+            await message.reply("✅ <b>Upload server set to: Telegram</b>\nVideos will be uploaded to your own channel and streamed via Hugging Face.")
+        elif mode in ["byse", "byse.sx", "external"]:
+            upload_mode = "byse"
+            await message.reply("✅ <b>Upload server set to: Byse.sx</b>\nVideos will be uploaded to Byse.sx and streamed via their player.")
+        else:
+            await message.reply("❌ <b>Invalid server!</b> Use `/upload telegram` or `/upload byse`.")
+    else:
+        await message.reply(f"📌 <b>Current Upload Server:</b> <code>{upload_mode.upper()}</code>\n\nTo change, use:\n👉 `/upload telegram` (Storage Channel Stream)\n👉 `/upload byse` (Byse.sx third-party player)")
+# ===============================================================
+
 @bot.on_message(filters.command("blur") & filters.private & filters.user(ADMIN_IDS))
 async def set_blur_state(client, message):
     try:
@@ -595,15 +618,26 @@ def upload_file_sync(upload_url, file_path, api_key):
     except Exception as e:
         return {}
 
-@bot.on_message((filters.video | filters.animation | filters.photo) & filters.private & filters.user(ADMIN_IDS))
+# filters.document যুক্ত করা হলো যাতে ফাইল/ডকুমেন্ট হিসেবে ভিডিও পাঠালেও বট প্রসেস করতে পারে
+@bot.on_message((filters.video | filters.animation | filters.photo | filters.document) & filters.private & filters.user(ADMIN_IDS))
 async def handle_media_upload(client, message):
+    global upload_mode
     state = admin_states.get(message.chat.id, {})
     if state.get("step") == "broadcast":
         await process_broadcast(client, message)
         return
 
+    # ফাইলটি ভিডিও, জিআইএফ নাকি ফটো তা নিখুঁতভাবে চেক করা হচ্ছে
+    is_video = message.video or (message.document and message.document.mime_type and "video" in message.document.mime_type)
+    is_animation = message.animation or (message.document and message.document.mime_type and "gif" in message.document.mime_type)
+    is_photo = message.photo or (message.document and message.document.mime_type and "image" in message.document.mime_type)
+
+    # যদি ভিডিও, ফটো বা অ্যানিমেশন না হয় তবে কাস্টম ফাইল স্কিপ করবে
+    if not (is_video or is_animation or is_photo):
+        return
+
     # FORCE ANIMATIONS (GIFS) TO BE TREATED AS VIDEOS FOR BROADCAST STABILITY
-    media_type = "video" if (message.video or message.animation) else "photo"
+    media_type = "video" if (is_video or is_animation) else "photo"
     has_blur_caption = message.caption and "/blur" in message.caption.lower()
     is_persistent_blur = bool(state.get("blur_percent"))
 
@@ -643,6 +677,7 @@ async def handle_media_upload(client, message):
 
     is_large_video = False
     if media_type == "video":
+        # Safe size checks for both Videos and Animations (GIFs/Documents)
         media = get_media_obj(message)
         duration = media.duration if media and hasattr(media, 'duration') and media.duration else 0
         file_size = media.file_size if media and hasattr(media, 'file_size') and media.file_size else 0
@@ -679,11 +714,13 @@ async def handle_media_upload(client, message):
         clean_upload_file = original_file 
         
         # ১. ওয়াটারমার্ক (Watermark) করা - Balanced (Superfast + CRF 23)
+        # জাইএফ (Animation) ফাইলের কোনো অডিও ট্র্যাক থাকে না, তাই এফএফএমপেগ ফেইল হওয়া ঠেকাতে অডিও বাইপাস করা হলো
         if media_type == "video" and not is_large_video:
             await status_msg.edit_text("⏳ Watermarking video... (HD + Superfast Processing)")
             watermarked_file = f"{original_file}_wm.mp4"
             
-            has_audio = not bool(message.animation)
+            # জাইএফ ফাইলের ক্ষেত্রে অডিও ট্র্যাক বাদ দেওয়া হবে (-an) অন্যথায় কপি করা হবে
+            has_audio = not (message.animation or (message.document and message.document.mime_type and "gif" in message.document.mime_type))
             audio_opts = ["-an"] if not has_audio else ["-c:a", "copy"]
             
             cmd = [
@@ -696,19 +733,17 @@ async def handle_media_upload(client, message):
             process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
             await process.communicate()
             
+            # বাগ সংশোধন: ফাইলের সাইজ ০-এর চেয়ে বেশি হলে তবেই আউটপুট ব্যবহার করা হবে, অন্যথায় অরিজিনাল ফাইল ব্যবহৃত হবে
             if process.returncode == 0 and os.path.exists(watermarked_file) and os.path.getsize(watermarked_file) > 0: 
                 clean_upload_file = watermarked_file
 
-        # ২. আপনার নিজের টেলিগ্রাম স্টোরেজ চ্যানেলে ফাইল আপলোড (ভিডিও বা ফটো)
-        # এখানে থাম্বনেইল, সঠিক ডিউরেশন এবং সাইজ জেনারেট করে পোস্ট করা হবে যাতে সাদা ০:০০ শো না করে
+        # ২. ভিডিও আপলোড (টেলিগ্রাম স্টোরেজ বা byse.sx - ইউজার সেটিং অনুযায়ী)
         storage_msg_id = None
-        if media_type in ["video", "photo"]:
-            await status_msg.edit_text(f"⏳ Uploading {media_type} to your storage channel...")
-            
-            if media_type == "photo":
-                sent_to_channel = await client.send_photo(chat_id=STORAGE_CHANNEL_ID, photo=clean_upload_file, caption="Backup of photo uploaded by Admin.")
-            else:
-                # ভিডিওর অরিজিনাল মেটাডাটা ও থাম্বনেইল বের করা হচ্ছে
+        if media_type == "video":
+            if upload_mode == "telegram":
+                await status_msg.edit_text("⏳ Uploading Clean HD video to your storage channel...")
+                
+                # স্টোরেজ চ্যানেলেও অরিজিনাল থাম্বনেইল, ডিউরেশন এবং সাইজ জেনারেট করে পাঠানো হচ্ছে যাতে সাদা ০:০০ শো না করে
                 thumb_path_storage = f"{original_file}_storage_thumb.jpg"
                 proc = await asyncio.create_subprocess_exec("ffmpeg", "-y", "-i", clean_upload_file, "-vframes", "1", thumb_path_storage, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
                 await proc.communicate()
@@ -729,13 +764,36 @@ async def handle_media_upload(client, message):
                     height=vid_height,
                     thumb=thumb_path_storage
                 )
-            
-            storage_msg_id = sent_to_channel.id
-            
-            # আপনার নিজস্ব ডোমেইন বা সার্ভারের স্ট্রিমিং ও ডিরেক্ট ডাউনলোড লিংক জেনারেট
-            stream_link = f"{BACKEND_URL}/stream/{storage_msg_id}"
-            download_link = f"{BACKEND_URL}/download/{storage_msg_id}"
-            embed_link = stream_link
+                storage_msg_id = sent_to_channel.id
+                
+                # আপনার নিজস্ব ডোমেইন বা সার্ভারের স্ট্রিমিং ও ডিরেক্ট ডাউনলোড লিংক জেনারেট
+                stream_link = f"{BACKEND_URL}/stream/{storage_msg_id}"
+                download_link = f"{BACKEND_URL}/download/{storage_msg_id}"
+                embed_link = stream_link
+            else:
+                # Byse.sx আপলোড মোড
+                await status_msg.edit_text("⏳ Uploading Clean HD video to byse.sx server...")
+                api_endpoint = "https://api.byse.sx/upload/server"
+                loop = asyncio.get_event_loop()
+                response = await loop.run_in_executor(None, lambda: requests.get(api_endpoint, params={'key': BYSE_API_KEY}, timeout=30))
+                result = response.json()
+                
+                if result.get('status') == 200:
+                    upload_res = await loop.run_in_executor(None, upload_file_sync, result.get('result'), clean_upload_file, BYSE_API_KEY)
+                    if upload_res.get('status') == 200 and 'files' in upload_res and len(upload_res['files']) > 0:
+                        file_status = upload_res['files'][0].get('status', '')
+                        if "not allowed" in str(file_status).lower():
+                            await status_msg.edit_text(f"❌ byse.sx rejected the file: <code>{file_status}</code>", parse_mode=enums.ParseMode.HTML)
+                            return
+                        file_code = upload_res['files'][0].get('filecode')
+                        if file_code: embed_link = f"https://bysesayeveum.com/e/{file_code}"
+                
+                if not embed_link:
+                    await status_msg.edit_text("❌ Uploaded to byse.sx but Embed Link not found.")
+                    return
+                
+                stream_link = embed_link
+                download_link = embed_link
 
         if is_large_video:
             admin_cap = f"✅ <b>Success! (Large Video)</b>\n\n🔗 <b>Embed Link (Clean HD):</b>\n<code>{embed_link or 'N/A'}</code>\n\n📌 <i>Broadcast skipped due to large file size.</i>"
@@ -759,16 +817,18 @@ async def handle_media_upload(client, message):
             else:
                 ff_filter = ["-vf", f"boxblur={radius}:1"]
             
+            # জাইএফ ফাইলের ক্ষেত্রে অডিও ট্র্যাক বাদ দেওয়া হবে (-an) অন্যথায় কপি করা হবে
+            has_audio = not (message.animation or (message.document and message.document.mime_type and "gif" in message.document.mime_type))
+            audio_opts_blur = ["-an"] if not has_audio else []
+            
             if media_type == "photo": 
                 cmd_blur = ["ffmpeg", "-y", "-i", clean_upload_file] + ff_filter + [blurred_file]
-            elif media_type == "animation": 
-                cmd_blur = ["ffmpeg", "-y", "-i", clean_upload_file] + ff_filter + ["-c:v", "libx264", "-preset", "superfast", "-pix_fmt", "yuv420p", blurred_file]
             else: 
-                cmd_blur = ["ffmpeg", "-y", "-i", clean_upload_file] + ff_filter + ["-c:v", "libx264", "-preset", "superfast", "-crf", "23", "-pix_fmt", "yuv420p", "-c:a", "copy", "-movflags", "+faststart", blurred_file]
+                cmd_blur = ["ffmpeg", "-y", "-i", clean_upload_file] + ff_filter + ["-c:v", "libx264", "-preset", "superfast", "-crf", "23", "-pix_fmt", "yuv420p"] + audio_opts_blur + ["-movflags", "+faststart", blurred_file]
             
             process_blur = await asyncio.create_subprocess_exec(*cmd_blur, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
             await process_blur.communicate()
-            if process_blur.returncode == 0 and os.path.exists(blurred_file): 
+            if process_blur.returncode == 0 and os.path.exists(blurred_file) and os.path.getsize(blurred_file) > 0: 
                 telegram_file = blurred_file
 
         await status_msg.edit_text("⏳ Preparing to broadcast to groups...")
@@ -795,8 +855,6 @@ async def handle_media_upload(client, message):
 
         if media_type == "photo":
             sent_to_admin = await client.send_photo(message.chat.id, telegram_file, caption=admin_cap, parse_mode=enums.ParseMode.HTML)
-        elif media_type == "animation":
-            sent_to_admin = await client.send_animation(message.chat.id, telegram_file, caption=admin_cap, parse_mode=enums.ParseMode.HTML)
         else:
             media = get_media_obj(message)
             vid_duration = media.duration if media and hasattr(media, 'duration') and media.duration else 0
@@ -950,54 +1008,10 @@ async def manual_clean_channel(client, message):
                             try: await temp_client.disconnect()
                             except: pass
                             await db_query(lambda: supabase.table('user_sessions').delete().eq('user_id', user_id).execute())
-                    
-                    if not is_valid:
-                        try:
-                            await bot.ban_chat_member(PREMIUM_CHANNEL_ID, user_id)
-                            await bot.unban_chat_member(PREMIUM_CHANNEL_ID, user_id) 
-                            kicked += 1
-                        except Exception: pass
-                        
-                await asyncio.sleep(1.5) 
-            except FloodWait as e:
-                await asyncio.sleep(e.value + 1)
-            except Exception:
-                pass
-            
-        await message.reply(f"✅ <b>Cleanup Complete!</b>\n\n👥 Members checked: {checked}\n👢 Users Kicked: {kicked}")
-    except Exception as e:
-        await message.reply(f"❌ Error: {e}")
-
-async def auto_clean_channel_loop():
-    await asyncio.sleep(60) 
-    while True:
-        try:
-            res_users = await db_query(lambda: supabase.table('referrals').select('user_id').execute())
-            if res_users.data:
-                user_ids = [u['user_id'] for u in res_users.data]
-                for user_id in set(user_ids):
-                    try:
-                        chat_member = await bot.get_chat_member(PREMIUM_CHANNEL_ID, user_id)
-                        if chat_member.status in [enums.ChatMemberStatus.MEMBER, enums.ChatMemberStatus.RESTRICTED]:
-                            res_session = await db_query(lambda: supabase.table('user_sessions').select('session_string').eq('user_id', user_id).execute())
-                            
-                            is_valid = False
-                            if res_session.data:
-                                session_string = res_session.data[0]['session_string']
-                                temp_client = Client(f"bg_chk_{user_id}", session_string=session_string, api_id=API_ID, api_hash=API_HASH, in_memory=True)
-                                try:
-                                    await temp_client.connect()
-                                    await temp_client.get_me()
-                                    await temp_client.disconnect()
-                                    is_valid = True
-                                except (SessionRevoked, AuthKeyUnregistered, UserDeactivated):
-                                    try: await temp_client.disconnect()
-                                    except: pass
-                                    await db_query(lambda: supabase.table('user_sessions').delete().eq('user_id', user_id).execute())
-                                except Exception:
-                                    try: await temp_client.disconnect()
-                                    except: pass
-                                    is_valid = True 
+                        except Exception:
+                            try: await temp_client.disconnect()
+                            except: pass
+                            is_valid = True 
                             
                             if not is_valid:
                                 try:
@@ -1014,7 +1028,7 @@ async def auto_clean_channel_loop():
         
         await asyncio.sleep(4 * 3600) 
 
-@bot.on_message(filters.private & filters.user(ADMIN_IDS) & ~filters.command(["start", "stats", "users", "broadcast", "png", "addvideo", "blur", "clean", "sendto", "clone"]))
+@bot.on_message(filters.private & filters.user(ADMIN_IDS) & ~filters.command(["start", "stats", "users", "broadcast", "png", "addvideo", "blur", "clean", "sendto", "clone", "upload"]))
 async def catch_admin_steps(client, message):
     state = admin_states.get(message.chat.id, {})
     if state.get("step") == 1: