main.py

import logging
import base64
import requests
import uvloop
import aiofiles
import aiohttp
from bs4 import BeautifulSoup
from akenoai import OldAkenoXToJs
from akenoai.runner import run_fast
from akenoai.clients import create_pyrogram
from akenoai.clients.enums import ChatMembersFilter
from akenoai.middleware.cors import CORSMiddleware

from pyrogram.enums import *
from pyrogram.errors import *
from pyrogram.types import *
from pyrogram import filters

from config import API_ID, API_HASH, BOT_TOKEN, SESSION

from src.catergory import router as catergory_router

logger = logging.getLogger(__name__)
LOGS = logging.getLogger("[akenox]")
logger.setLevel(logging.DEBUG)

js = OldAkenoXToJs()
fast_app = js.get_app()
js.add_cors_middleware()

import uvloop

uvloop.install()

from src.combo import router as combo_router
# from src.recent_torrents import router as recent_torrents_router
# from src.search_torrent_url import router as search_torrent_url_router
# from src.search_torrents import router as search_torrents_router
from src.sites_list_torrens import router as sites_list_torrens_router
# from src.trending_torrents import router as trending_torrents_router

# torrent router
fast_app.include_router(combo_router)
fast_app.include_router(catergory_router)
# fast_app.include_router(recent_torrents_router)
# fast_app.include_router(search_torrent_url_router)
# fast_app.include_router(search_torrents_router)
fast_app.include_router(sites_list_torrens_router)
# fast_app.include_router(sites_list_torrens_router)
# fast_app.include_router(trending_torrents_router)


bot = create_pyrogram(
    name="fastapi-bot",
    api_id=API_ID,
    api_hash=API_HASH,
    bot_token=BOT_TOKEN
)

user_client = create_pyrogram(
    name="fastapi-user",
    api_id=API_ID,
    api_hash=API_HASH,
    session_string=SESSION
)

def get_random_from_channel(link):
    clean_link = link.split("?")[0]
    target_link = clean_link.split("/c/") if "/c/" in clean_link else clean_link.split("/")
    random_id = int(target_link[-1].split("/")[-1]) if len(target_link) > 1 else None
    desired_username = target_link[3] if len(target_link) > 3 else None
    username = (
        "@" + desired_username if desired_username else "-100" + target_link[1].split("/")[0]
        if len(target_link) > 1 else None
    )
    return username, random_id

async def upload_to_catbox(dl_path: str) -> str:
    base_url = "https://catbox.moe/user/api.php"
    proxy_url = f"http://186.26.92.180:58339"
    async with aiohttp.ClientSession() as session:
        form_data = aiohttp.FormData()
        form_data.add_field("reqtype", "fileupload")

        async with aiofiles.open(dl_path, mode="rb") as file:
            file_data = await file.read()
            form_data.add_field(
                "fileToUpload",
                file_data,
                filename=dl_path.split("/")[-1],
                content_type="application/octet-stream"
            )

        async with session.post(base_url, data=form_data, proxy=proxy_url) as response:
            response.raise_for_status()
            return (await response.text()).strip()

@fast_app.on_event("startup")
async def startup_event():
    user = await bot.start()
    userbot = await user_client.start()
    LOGS.info(f"Started Bot: {user.me.first_name}")
    LOGS.info(f"Started UserBot: {userbot.me.first_name}")
    
@fast_app.get("/user/status/ban")
async def user_status_ban(username: str = None):
    username_ch = "RendyProjects"
    try:
        mention_user = await bot.get_users(username)
        user = await bot.get_chat_member(username_ch, username)
        if user.status == ChatMemberStatus.BANNED:
            return {
                "message": f"❌ you {mention_user.first_name} have been blocked from the RendyProjects",
                "is_ban": True,
                "user_id": mention_user.id
            }
        return {
            "message": "User is not banned",
            "is_ban": False,
            "user_id": mention_user.id
        }
    except PeerIdInvalid:
        return False
    except UserNotParticipant:
        return False

async def hello():
    return {"success": "hello world!"}

@fast_app.get("/user/get_story")
async def get_user_story(link: str = None):
    username, random_id = get_random_from_channel(link)
    try:
        stories = await user_client.get_stories(username, story_ids=[random_id])
    except Exception as e:
        return {"error": str(e)}
    if stories:
        for story in stories:
            file_id = (
                story.photo.file_id if story and story.photo else None
                or story.video.file_id if story and story.video else None
            )
            caption = story.caption or f"By {user_client.me.mention}"
            if file_id:
                image_path = await user_client.download_media(file_id)
                
                with open(image_path, "rb") as f:
                    base64_image = base64.b64encode(f.read()).decode("utf-8")
                # url_dl = await upload_to_catbox(image_path)
                return {
                    "download": base64_image,
                    "random_file_id": file_id,
                    "caption": caption
                }
    return {
        "download": None,
        "random_file_id": None,
        "caption": None
    }

@fast_app.get("/user/media-dl/file_id")
async def get_download_media_file(file_id: str = None):
    try:
        image_path = await user_client.download_media(file_id)
    except Exception as e:
        return {"error": str(e)}
    with open(image_path, "rb") as f:
        base64_image = base64.b64encode(f.read()).decode("utf-8")
    return {
        "download": base64_image,
    }

ALERT_WARN = """
🚨 Security Alert: API Key Activity Detected!  

👁️ Full Log:

`{text_log}`

🔗 Need help? Contact support: @xpushz  
"""

NOTIF_KEY = """
🚨 **Notification: API Key Expired (Premium Required)!**  

Your current API key has expired. To continue using premium features, please upgrade to **Premium v2** first.  

🔑 **API Key:** <spoiler>{api_key}</spoiler>  

🔗 Need help? Contact support: @xpushz
"""

@bot.on_callback_query(filters.regex("^alert_"))
async def _alert(_, cb):
    query = cb.data.split("_", 1)
    await cb.answer(query, show_alert=True)

@fast_app.get("/user/tg/notifications")
async def user_send_notif(user_id: int = None, api_key: str = None):
    try:
        await bot.send_sticker(
            user_id,
            "CAACAgUAAyEGAASPgam4AAI5T2fTWtyF4FNdBlRL-PWcs_l3Y0emAAI-BwACj774VGLOns79NgeCHgQ"
        )
        await bot.send_message(
            user_id,
            text=NOTIF_KEY.format(api_key=api_key)
        )
        return {"status": True}
    except Exception as e:
        return None

@fast_app.get("/user/tg/send_message")
async def user_send_message(user_id: int = None, api_key: str = None, text_log: str = None):
    try:
        await bot.send_message(
            user_id,
            text=ALERT_WARN.format(
                api_key=api_key,
                text_log=text_log
            )
        )
        return {"status": True}
    except Exception as e:
        return None

@fast_app.get("/user/author/admin")
async def get_author_chat_admin(username: str = None):
    same_user = {}
    async for m in user_client.get_chat_members(username, filter=ChatMembersFilter.ADMINISTRATORS):
        if not m.user.is_bot and not m.user.is_deleted:
            same_user[m.user.id] = {
                "first_name": m.user.first_name,
                "username": m.user.username if m.user else None
            }
    return {  
        "admin_list": same_user  
    }

@fast_app.get("/user/raw/getchat")
async def get_chat_raw(username: str = None):
    try:
        user_id = None
        chat_raw = (await bot.get_chat(username)).raw
        ok = await user_client.get_chat(username)
        if ok.pinned_message.from_user:
            user_id = ok.pinned_message.from_user.id if ok.pinned_message.from_user else None
        if not user_id:
            user_id = None
        if user_id:
            response = await js.get_creation_date(
                user_id=user_id
            )
    except Exception as e:
        return {"error": f"Error try again invalid: {str(e)}"}
    return {
        "id": chat_raw.id,
        "about": chat_raw.about,
        "title": ok.title,
        "username": ok.username if ok else None,
        "photo": {
            "id": chat_raw.chat_photo.id,
            "small_file_id": ok.photo.small_file_id,
            "small_photo_unique_id": ok.photo.small_photo_unique_id,
            "big_file_id": ok.photo.big_file_id,
            "big_photo_unique_id": ok.photo.big_photo_unique_id,
            "date": chat_raw.chat_photo.date,
            "dc_id": chat_raw.chat_photo.dc_id,
            "has_animation": ok.photo.has_animation,
            "is_personal": ok.photo.is_personal
        },
        "from_user": {
            "id": ok.pinned_message.from_user.id if ok.pinned_message.from_user else None,
            "first_name": ok.pinned_message.from_user.first_name if ok.pinned_message.from_user else None,
            "last_name": ok.pinned_message.from_user.last_name if ok.pinned_message.from_user else None,
            "status": ok.pinned_message.from_user.status.name if ok.pinned_message.from_user.status else None,
            "last_online_date": ok.pinned_message.from_user.last_online_date if ok.pinned_message.from_user else None,
            "username": ok.pinned_message.from_user.username if ok.pinned_message.from_user else None,
            "is_premium": ok.pinned_message.from_user.is_premium if ok.pinned_message.from_user else None,
            "is_scam": ok.pinned_message.from_user.is_scam if ok.pinned_message.from_user else None,
            "creation_date": response
        },
        "can_view_participants": chat_raw.can_view_participants,
        "can_set_username": chat_raw.can_set_username,
        "can_set_stickers": chat_raw.can_set_stickers,
        "hidden_prehistory": chat_raw.hidden_prehistory,
        "can_set_location": chat_raw.can_set_location,
        "has_scheduled": chat_raw.has_scheduled,
        "can_view_stats": chat_raw.can_view_stats,
        "blocked": chat_raw.blocked,
        "can_delete_channel": chat_raw.can_delete_channel,
        "antispam": chat_raw.antispam,
        "participants_hidden": chat_raw.participants_hidden,
        "translations_disabled": chat_raw.translations_disabled,
        "stories_pinned_available": chat_raw.stories_pinned_available,
        "view_forum_as_messages": chat_raw.view_forum_as_messages,
        "restricted_sponsored": chat_raw.restricted_sponsored,
        "can_view_revenue": chat_raw.can_view_revenue,
        "paid_media_allowed": chat_raw.paid_media_allowed,
        "can_view_stars_revenue": chat_raw.can_view_stars_revenue,
        "paid_reactions_available": chat_raw.paid_reactions_available,
        "stargifts_available": chat_raw.stargifts_available,
        "participants_count": chat_raw.participants_count,
        "online_count": chat_raw.online_count,
        "pinned_msg_id": chat_raw.pinned_msg_id,
        "linked_chat_id": chat_raw.linked_chat_id,
        "pending_suggestions": chat_raw.pending_suggestions,
        "recent_requesters": chat_raw.recent_requesters,
        "available_reactions": {
            "allow_custom": chat_raw.available_reactions.allow_custom
        },
    }

async def send_to_telegram(user_id="@xpushz", text: str = None):
    return await bot.send_message(user_id, text=text)

@fast_app.post("/log_captcha")
async def log_captcha(data: dict):
    user_ip = data.get("user_ip", "Unknown IP")
    timestamp = data.get("challenge_ts", "No Timestamp")
    log_message = f"✅ CAPTCHA Verified\n🖥 IP: `{user_ip}`\n⏳ Time: `{timestamp}`"
    await send_to_telegram(text=log_message)
    return {"status": "logged"}

@fast_app.get("/api/twitter")
async def twitter_downloader(link: str):
    # credits @xpushz don't remove credits here
    import akenoai as jsx
    import re
    if not link:
        return {"error": "required link"}
    urls = re.sub(r"(https?:\/\/)(?:www\.)?x\.com", r"\1twitter.com", link)
    if not urls:
        return {"error": None}
    response = await jsx.fetch_and_extract_urls(
        f"https://snapdownloader.com/tools/twitter-video-downloader/download?url={urls}",
        href_url=r"https://video",
        return_unsafe_href=True
    )
    return {"results": response}

@fast_app.get("/user/get_user")
async def get_user(user_id=None):
    try:
        get_users = await bot.get_users(user_id)
        response = await js.get_creation_date(
            user_id=get_users.id
        )
    except Exception:
        return {"error": "Error try again invalid"}
    return {
        "id": get_users.id,
        "is_self": get_users.is_self,
        "is_contact": get_users.is_contact,
        "is_mutual_contact": get_users.is_mutual_contact,
        "is_deleted": get_users.is_deleted,
        "is_bot": get_users.is_bot,
        "is_verified": get_users.is_verified,
        "is_restricted": get_users.is_restricted,
        "is_scam": get_users.is_scam,
        "is_fake": get_users.is_fake,
        "is_support": get_users.is_support,
        "is_premium": get_users.is_premium,
        "is_contact_require_premium": get_users.is_contact_require_premium,
        "is_close_friend": get_users.is_close_friend,
        "is_stories_hidden": get_users.is_stories_hidden,
        "is_stories_unavailable": get_users.is_stories_unavailable,
        "is_business_bot": get_users.is_business_bot,
        "first_name": get_users.first_name,
        "status": get_users.status.name,
        "last_online_date": get_users.last_online_date,
        "dc_id": get_users.dc_id,
        "username": get_users.username if get_users else None,
        "photo": {
            "small_file_id": get_users.photo.small_file_id,
            "small_photo_unique_id": get_users.photo.small_photo_unique_id,
            "big_file_id": get_users.photo.big_file_id,
            "has_animation": get_users.photo.has_animation,
            "is_personal": get_users.photo.is_personal
        },
        "creation_date": response
    }

js.custom_openapi(
    app=fast_app,
    title="AkenoX Beta AI API",
    version="1.0.0",
    summary="Use It Only For Personal Project",
    description="Free API By akenoai-lib",
    routes=fast_app.routes,
)

run_fast(build=fast_app, port=7860)