Upload 19 files

Dockerfile

@@ -18,4 +18,4 @@ COPY . .
 RUN pip3 install --upgrade pip setuptools
 RUN pip3 install -r requirements.txt
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,8 @@
 ---
-title: Ryuzaki Api
+title: UFoP Api
 emoji: 📈
-colorFrom: pink
-colorTo: purple
+colorFrom: red
+colorTo: blue
 sdk: docker
 pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---

functions.py

@@ -29,4 +29,4 @@ def ryuzaki_ai_text(text):
     API_URL = SOURCE_ALPHA_URL
     headers = {"Authorization": f"Bearer {HUGGING_TOKEN}"}
     response = requests.post(API_URL, headers=headers, json={"inputs": text})
-    return response.json()
+    return response.json()

main.py

@@ -25,19 +25,17 @@ import uvicorn
 import os
 import shutil
 import random
+import g4f
 import tempfile
 import io
-import openai
 from io import BytesIO
 from datetime import datetime as dt
 from dotenv import load_dotenv
 from bs4 import BeautifulSoup
 
-from typing import *
+from typing import Union
 from typing_extensions import Annotated
 from typing import Annotated, Union
-from typing import Optional, List, Dict, Any
-
 
 from pydantic import BaseModel
 from base64 import b64decode as kc
@@ -49,10 +47,9 @@ from telegraph import Telegraph, upload_file
 from pathlib import Path
 from serpapi import GoogleSearch
 
-from fastapi import FastAPI, UploadFile, File, Response
+from fastapi import FastAPI, UploadFile, File
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from fastapi import Depends, FastAPI, HTTPException, status
-from fastapi.openapi.utils import get_openapi
 from fastapi.responses import StreamingResponse
 from fastapi import HTTPException
 from fastapi import FastAPI, Request, Header
@@ -61,70 +58,50 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import FileResponse
 
-from pymongo import MongoClient
-
 from RyuzakiLib.hackertools.chatgpt import RendyDevChat
 from RyuzakiLib.hackertools.openai_api import OpenAiToken
 from RyuzakiLib.mental import BadWordsList
-from RyuzakiLib.system import OpenReadSystem
-
-from bardapi import Bard
-
-from models import *
-
-from gpytranslate import SyncTranslator
+from RyuzakiLib.spamwatch.clients import SibylBan
 
 import logging
+import database as db
 import functions as code
 
 logging.basicConfig(level=logging.ERROR)
 
-
+# I DON'T KNOW LIKE THIS HACKER
 load_dotenv()
-
-# Database url
-MONGO_URL = os.environ["MONGO_URL"]
-
-# source url
+REVERSE_IMAGE_API = os.environ["REVERSE_IMAGE_API"]
+OCR_API_KEY = os.environ["OCR_API_KEY"]
+ONLY_DEVELOPER_API_KEYS = os.environ["ONLY_DEVELOPER_API_KEYS"]
+HUGGING_TOKEN = os.environ["HUGGING_TOKEN"]
 SOURCE_UNSPLASH_URL = os.environ["SOURCE_UNSPLASH_URL"]
 SOURCE_OCR_URL = os.environ["SOURCE_OCR_URL"]
 SOURCE_ALPHA_URL = os.environ["SOURCE_ALPHA_URL"]
-SOURCE_OPENDALLE_URL = os.environ["SOURCE_OPENDALLE_URL"]
-SOURCE_ANIME_STYLED_URL = os.environ["SOURCE_ANIME_STYLED_URL"]
-SOURCE_WAIFU_URL = os.environ["SOURCE_WAIFU_URL"]
+SOURCE_WAIFU_URL = "https://api.waifu.pics"
 SOURCE_TIKTOK_WTF_URL = os.environ["SOURCE_TIKTOK_WTF_URL"]
 SOURCE_TIKTOK_TECH_URL = os.environ["SOURCE_TIKTOK_TECH_URL"]
-SOURCE_WHAT_GAY_URL = os.environ["SOURCE_WHAT_GAY_URL"]
-SOURCE_ASSISTANT_GOOGLE_AI = os.environ["SOURCE_ASSISTANT_GOOGLE_AI"]
-SOURCE_OPENAI_ACCESS_URL = os.environ["SOURCE_OPENAI_ACCESS_URL"]
+DEVELOPER_ID = os.environ["DEVELOPER_ID"]
 
-# api keys
-REVERSE_IMAGE_API = os.environ["REVERSE_IMAGE_API"]
-OCR_API_KEY = os.environ["OCR_API_KEY"]
-ONLY_DEVELOPER_API_KEYS = os.environ["ONLY_DEVELOPER_API_KEYS"]
-HUGGING_TOKEN = os.environ["HUGGING_TOKEN"]
-ASSISTANT_GOOGLE_API_KEYS = os.environ["ASSISTANT_GOOGLE_API_KEYS"]
-#COOKIE_BARD_TOKEN = os.environ["COOKIE_BARD_TOKEN"]
-
-client_mongo = MongoClient(MONGO_URL)
-db = client_mongo["tiktokbot"]
-collection = db["users"]
-
-trans = SyncTranslator()
-
-app = FastAPI(docs_url=None, redoc_url="/")
+description = """
+~ Developed written and powered by
+- Ryuzaki Library: [Library Here](https://github.com/TeamKillerX/RyuzakiLib)
+"""
 
-def get_all_api_keys():
-    user = collection.find({})
-    api_keys = []
-    for x in user:
-        api_key = x.get("ryuzaki_api_key")
-        if api_key:
-            api_keys.append(api_key)
-    return api_keys
+app = FastAPI(
+    title="UFoP-API",
+    description=description,
+    version="0.1.0",
+    terms_of_service="Use It Only For Personal Project Else I Need To Delete The Api",
+    contact={
+        "name": "🌀ʊʄ⊕ք🌀",
+        "url": "https://t.me/UFoPInfo",
+    },
+    docs_url="/"
+)
 
 def validate_api_key(api_key: str = Header(...)):
-    USERS_API_KEYS = get_all_api_keys()
+    USERS_API_KEYS = db.get_all_api_keys()
     if api_key not in USERS_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
@@ -132,151 +109,10 @@ def validate_api_key_only_devs(api_key: str = Header(...)):
     if api_key not in ONLY_DEVELOPER_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
-RAMDOM_STATUS = [
-    "civilian",
-    "wanted",
-    "undercover",
-    "rogue_agent",
-    "innocent",
-    "fugitive",
-    "covert_operator"
-]
-
-def remove_sibyl_system_banned(user_id):
-    update_doc = {
-        "sibyl_ban": None,
-        "reason_sibyl": None,
-        "is_banned_sibly": None,
-        "date_joined_sib": None,
-        "sibyl_userid": None
-    }
-    return collection.update_one({"user_id": user_id}, {"$unset": update_doc}, upsert=True)
-
-def new_sibyl_system_banned(user_id, name, reason, date_joined):
-    update_doc = {
-        "sibyl_ban": name,
-        "reason_sibyl": reason,
-        "is_banned_sibly": True,
-        "date_joined_sib": date_joined,
-        "sibyl_userid": user_id
-    }
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
-
-def get_sibyl_system_banned(user_id):
-    user = collection.find_one({"user_id": user_id})
-    if user:
-        sibyl_name = user.get("sibyl_ban")
-        reason = user.get("reason_sibyl")
-        is_banned = user.get("is_banned_sibly")
-        date_joined = user.get("date_joined_sib")
-        sibyl_user_id = user.get("sibyl_userid")
-        return sibyl_name, reason, is_banned, date_joined, sibyl_user_id
-    else:
-        return None
-
-def get_all_banned():
-    banned_users = []
-
-    users = collection.find({})
-
-    for user_id in users:
-        reason = user_id.get("reason_sibyl")
-        user_id = user_id.get("sibyl_userid")
-        banned_users.append({"user_id": user_id, "reason": reason})
-    return banned_users
-
-def new_profile_clone(
-    user_id,
-    first_name,
-    last_name=None,
-    profile_id=None,
-    bio=None
-):
-    update_doc = {
-        "first_name_2": first_name,
-        "last_name_2": last_name,
-        "profile_id_2": profile_id,
-        "bio_2": bio
-    }
-    collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
-
-def get_profile_clone(user_id):
-    user = collection.find_one({"user_id": user_id})
-    if user:
-        first_name = user.get("first_name_2")
-        last_name = user.get("last_name_2")
-        profile_id = user.get("profile_id_2")
-        bio = user.get("bio_2")
-        return first_name, last_name, profile_id, bio
-    else:
-        return None
-
-@app.post("/ryuzaki/profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def profile_clone(
-    item: ProfileClone,
-    api_key: None = Depends(validate_api_key)
-):
-    if item.user_id == 1191668125:
-        return {"status": "false", "message": "Only Developer"}
-
-    try:
-        new_profile_clone(
-            user_id=item.user_id,
-            first_name=item.first_name,
-            last_name=item.last_name,
-            profile_id=item.profile_id,
-            bio=item.bio
-        )
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "user_id": item.user_id,
-                "first_name": item.first_name,
-                "last_name": item.last_name,
-                "profile_id": item.profile_id,
-                "bio": item.bio
-            }
-        )
-    except Exception as e:
-        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
-
-@app.get("/ryuzaki/get-profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def get_profile_(
-    item: GetProfileClone,
-    api_key: None = Depends(validate_api_key)
-):
-    try:
-        first_name, last_name, profile_id, bio = get_profile_clone(item.user_id)
-        if last_name is None:
-            last_name_str = ""
-        else:
-            last_name_str = last_name
-        if bio is None:
-            bio_str = ""
-        else:
-            bio_str = bio
-        if first_name and profile_id:
-            return SuccessResponse(
-                status="True",
-                randydev={
-                    "user_id": item.user_id,
-                    "first_name": first_name,
-                    "last_name": last_name_str,
-                    "profile_id": profile_id,
-                    "bio": bio_str
-                }
-            )
-        else:
-            return SuccessResponse(
-                status="False",
-                randydev={"message": "Not found user"}
-            )
-    except Exception as e:
-        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
 @app.get("/UFoP/getbanlist")
 def sibyl_get_all_banlist():
-    banned_users = get_all_banned()
+    banned_users = db.get_all_banned()
     return {
         "status": "True",
         "randydev": {
@@ -284,7 +120,7 @@ def sibyl_get_all_banlist():
         }
     }
 
-@app.get("/ryuzaki/blacklist-words")
+@app.get("/UFoP/blacklist-words")
 def blacklist_words():
     try:
         BLACKLIST_WORDS = BadWordsList()
@@ -293,130 +129,128 @@ def blacklist_words():
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.delete("/UFoP/sibyldel", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+@app.delete("/UFoP/bandel")
 def sibyl_system_delete(
-    item: SibylSystemDel,
+    user_id: int = Query(..., description="User ID in query parameter only developer"),
     api_key: None = Depends(validate_api_key_only_devs)
 ):
     try:
-        _, _, _, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
+        _, _, _, _, sibyl_user_id = db.get_sibyl_system_banned(user_id)
 
         if sibyl_user_id:
-            remove_sibyl_system_banned(item.user_id)
-            return SuccessResponse(
-                status="True",
-                randydev={"message": f"Successfully removed {item.user_id} from the Sibyl ban list"}
-            )
+            db.remove_sibyl_system_banned(user_id)
+            return {"status": "true", "message": f"Successfully removed {user_id} from the Sibyl ban list."}
         else:
-            return SuccessResponse(
-                status="False",
-                randydev={"message": "Not Found UserID"}
-            )
+            return {"status": "false", "message": "Not found user"}
     except Exception as e:
-        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
+        return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.post("/UFoP/sibylban", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+@app.post("/UFoP/banner")
 def sibyl_system_ban(
-    item: SibylSystemBan,
+    user_id: int = Query(..., description="User ID in query parameter"),
+    reason: str = Query(..., description="Reason in query parameter"),
     api_key: None = Depends(validate_api_key_only_devs)
 ):
-    if item.user_id == 1191668125:
+    if user_id == int(DEVELOPER_ID):
         return {"status": "false", "message": "Only Developer"}
 
     try:
         date_joined = str(dt.now())
-        sibyl_ban = random.choice(RAMDOM_STATUS)
-        _, _, is_banned, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
-
-        if sibyl_user_id and is_banned:
+        sibyl_ban = random.choice(db.RAMDOM_STATUS)
+        ban_data = db.get_sibyl_system_banned(user_id)
+        
+        if ban_data is not None:
+            _, _, is_banned, _, sibyl_user_id = ban_data
             return {"status": "false", "message": "User is already banned"}
 
-        new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "user_id": item.user_id,
+        db.new_sibyl_system_banned(user_id, sibyl_ban, reason, date_joined)
+
+        return {
+            "status": "true",
+            "randydev": {
+                "user_id": user_id,
                 "sibyl_name": sibyl_ban,
-                "reason": item.reason,
+                "reason": reason,
                 "date_joined": date_joined,
-                "message": f"Successfully banned {item.user_id} from the Sibyl ban list."
+                "message": f"Successfully banned {user_id} from the Sibyl ban list."
             }
-        )
+        }
     except Exception as e:
-        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
+        logging.error(f"Error in sibyl_system_ban: {e}")
+        return {"status": "false", "message": "Internal server error"}
 
-@app.get("/UFoP/sibyl", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+@app.get("/UFoP/bans")
 def sibyl_system(
-    item: SibylSystem,
-    api_key: None = Depends(validate_api_key)
+    user_id: int = Query(..., description="User ID in query parameter"),
+    api_key: None = Depends(validate_api_key) or Depends(validate_api_key_only_devs)
 ):
-    sibyl_result = get_sibyl_system_banned(item.user_id)
-    if sibyl_result:
-        sibyl_name, reason, is_banned, date_joined, sibyl_user_id = sibyl_result
-        return SuccessResponse(
-            status="True",
-            randydev={
+    result = db.get_sibyl_system_banned(user_id)
+    if result is not None:
+        sibyl_name, reason, is_banned, date_joined, sibyl_user_id = result
+        return {
+            "status": "true",
+            "randydev": {
                 "sibyl_name": sibyl_name,
                 "reason": reason,
                 "is_banned": is_banned,
                 "date_joined": date_joined,
                 "sibyl_user_id": sibyl_user_id
             }
-        )
+        }
     else:
-        return SuccessResponse(
-            status="false",
-            randydev={
-                "message": "Not found user"
-            }
-        )
+        return {"status": "false", "message": "Not Found User"}
 
-@app.get("/ryuzaki/pypi-search", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def pypi_search(
-    item: TextCustom,
+@app.get("/ryuzaki/ai")
+def ryuzaki_ai(
+    text: str = Query(..., description="text in query parameter"),
+    api_key: None = Depends(validate_api_key_only_devs)
 ):
     try:
-        response = OpenReadSystem()
-        response.code_system = f"pip3 show {item.query}"
-        hack = response.show(read_system=True)
-        return SuccessResponse(
-            status="True",
-            randydev={"results": hack})
-    except:
-        return SuccessResponse(
-            status="True",
-            randydev={"message": "Error not responding"})
+        response_data = code.ryuzaki_ai_text(text)
+
+        if isinstance(response_data, list) and len(response_data) > 0:
+            first_result = response_data[0]
+            if "generated_text" in first_result:
+                message = first_result["generated_text"]
+                return {
+                    "status": "true",
+                    "randydev": {
+                        "ryuzaki_text": message
+                    }
+                }
+
+        return {"status": "false", "message": "Invalid response format"}
+
+    except Exception as e:
+        return {"status": "false", "message": f"error: {e}"}
+
+@app.get("/ryuzaki/unsplash")
+async def get_image_unsplash(query: str, size: str="500x500"):
+    url = SOURCE_UNSPLASH_URL
+    image_url = f"{url}/?{query}/{size}"
 
-@app.get("/ryuzaki/translate", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def get_translate(
-    item: TranslateCustom,
-):
     try:
-        source = trans.detect(item.text)
-        translation = trans(item.text, sourcelang=source, targetlang=item.setlang)
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "translation": translation.text,
-                "translation_original": item.text
-            }
-        )
-    except:
-        return SuccessResponse(
-            status="True",
-            randydev={"message": "Error not responding"})
+        response = requests.get(image_url)
+        response.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching image: {e}")
 
-@app.get("/ryuzaki/reverse", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+    return StreamingResponse(BytesIO(response.content), media_type="image/jpeg")
+
+@app.get("/ryuzaki/reverse")
 def google_reverse(
-    item: GoogleReverse,
+    engine: str="google_reverse_image",
+    image_url: str=None,
+    language: str="en",
+    google_lang: str="us",
     api_key: None = Depends(validate_api_key)
 ):
     params = {
         "api_key": REVERSE_IMAGE_API,
-        "engine": item.engine,
-        "image_url": item.image_url,
-        "hl": item.language,
-        "gl": item.google_lang
+        "engine": engine,
+        "image_url": image_url,
+        "hl": language,
+        "gl": google_lang
     }
     try:
         search = GoogleSearch(params)
@@ -425,28 +259,30 @@ def google_reverse(
         total_time_taken = results["search_metadata"]["total_time_taken"]
         create_at = results["search_metadata"]["created_at"]
         processed_at = results["search_metadata"]["processed_at"]
-        return SuccessResponse(
-            status="True",
-            randydev={
+        return {
+            "status": "true",
+            "randydev": {
                 "link": link,
                 "total_time_taken": total_time_taken,
                 "create_at": create_at,
                 "processed_at": processed_at
             }
-        )
-    except Exception:
-        return {"status": "false", "message": "Internal server error"}
+        }
+    except Exception as e:
+        return {"status": "false", "message": f"Error {e}"}
 
-@app.get("/ryuzaki/ocr", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+@app.get("/ryuzaki/ocr")
 def ocr_space_url(
-    item: OrcSpaceUrl,
+    url: str = Query(..., description="URL in query parameter"),
+    overlay: bool=False,
+    language: str = Query("eng", description="Language in query parameter"),
     api_key: None = Depends(validate_api_key)
 ):
     payload = {
-        "url": item.url,
-        "isOverlayRequired": item.overlay,
+        "url": url,
+        "isOverlayRequired": overlay,
         "apikey": OCR_API_KEY,
-        "language": item.language
+        "language": language
     }
     try:
         response = requests.post(SOURCE_OCR_URL, data=payload)
@@ -457,403 +293,53 @@ def ocr_space_url(
     try:
         parsed_response = json.loads(test_url)
         if "ParsedResults" in parsed_response and len(parsed_response["ParsedResults"]) > 0:
-            return SuccessResponse(
-                status="True",
-                randydev={
+            return {
+                "status": "true",
+                "randydev":{
                     "text": parsed_response["ParsedResults"][0]["ParsedText"]
                 }
-            )
+            }
         else:
             return {"status": "false", "message": "Error response."}
     except (json.JSONDecodeError, KeyError):
         return "Error parsing the OCR response."
 
-@app.get("/ryuzaki/freechatgpt-beta", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def free_chatgpt4_beta(item: ChatgptCustom):
-    try:
-        response = RendyDevChat(item.query).get_response_beta(joke=True)
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "message": response
-            }
-        )
-    except:
-        return {"status": "false", "message": "Error response."}
-
-@app.get("/ryuzaki/freechatgpt-bing", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def free_chatgpt4_bing(item: ChatgptCustom):
-    try:
-        response = RendyDevChat(query).get_response_bing(bing=True)
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "message": response
-            }
-        )
-    except:
-        return {"status": "false", "message": "Error response."}
-
-@app.post("/ryuzaki/ai", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def ryuzaki_ai(
-    item: RyuzakiAi,
-    api_key: None = Depends(validate_api_key)
-):
-    try:
-        response_data = code.ryuzaki_ai_text(item.text)
-
-        if isinstance(response_data, list) and len(response_data) > 0:
-            first_result = response_data[0]
-            if "generated_text" in first_result:
-                message = first_result["generated_text"]
-                return SuccessResponse(
-                    status="True",
-                    randydev={
-                        "ryuzaki_text": message
-                    }
-                )
-        return {"status": "false", "message": "Invalid response format"}
-
-    except Exception:
-        return {"status": "false", "message": "Internal server error"}
-
-@app.post("/ryuzaki/opendalle")
-def open_dalle(
-    item: OpenDalle,
+@app.get("/ryuzaki/chatgpt4")
+def chatgpt4_support(
+    query: str=None,
     api_key: None = Depends(validate_api_key)
 ):
-    API_URL = SOURCE_OPENDALLE_URL
-    try:
-        payload = {"inputs": item.query}
-        headers = {"Authorization": f"Bearer {HUGGING_TOKEN}"}
-        response = requests.post(API_URL, headers=headers, json=payload)
-        response.raise_for_status()
-    except requests.exceptions.RequestException:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
-        )
     try:
-        encoded_string = base64.b64encode(response.content).decode("utf-8")
-    except Exception:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
+        response = g4f.ChatCompletion.create(
+            model=g4f.models.gpt_4,
+            messages=[{"role": "user", "content": query}],
         )
-    if encoded_string:
-        return SuccessResponse(status="True", randydev={"data": encoded_string})
-    else:
-        return SuccessResponse(status="False", randydev={"data": "Not found image data"})
-
-@app.post("/ryuzaki/anime-styled")
-def Anime_Styled(
-    item: AnimeStyled,
-    api_key: None = Depends(validate_api_key)
-):
-    API_URL = SOURCE_ANIME_STYLED_URL
-    try:
-        payload = {"inputs": item.query}
-        headers = {"Authorization": f"Bearer {HUGGING_TOKEN}"}
-        response = requests.post(API_URL, headers=headers, json=payload)
-        response.raise_for_status()
-    except requests.exceptions.RequestException:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
-        )
-    try:
-        encoded_string = base64.b64encode(response.content).decode("utf-8")
-    except Exception:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
-        )
-    if encoded_string:
-        return SuccessResponse(status="True", randydev={"data": encoded_string})
-    else:
-        return SuccessResponse(status="False", randydev={"data": "Not found image data"})
-
-@app.post("/ryuzaki/unsplash")
-def image_unsplash(item: GetImageUnsplash):
-    url = SOURCE_UNSPLASH_URL
-    image_url = f"{url}/?{item.query}/{item.size}"
-    try:
-        response = requests.get(image_url)
-        response.raise_for_status()
-    except requests.exceptions.RequestException:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
-        )
-    try:
-        encoded_string = base64.b64encode(response.content).decode("utf-8")
-    except Exception:
-        raise HTTPException(
-            status_code=500,
-            detail=CustomErrorResponseModel(detail=[{}])
-        )
-    if encoded_string:
-        return SuccessResponse(status="True", randydev={"data": encoded_string})
-    else:
-        return SuccessResponse(status="False", randydev={"data": "Not found image data"})
-
-@app.post("/ryuzaki/chatgpt-model", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def chatgpt_model(item: ChatgptModel):
-    url = "https://lexica.qewertyy.me/models"
-    if item.is_models:
-        params = {"model_id": item.model_id, "prompt": item.query}
-        response = requests.post(url, params=params)
-        if response.status_code != 200:
-            return f"Error status: {response.status_code}"
-        check_response = response.json()
-        answer = check_response.get("content")
-        return SuccessResponse(
-            status="True",
-            randydev={"message": answer}
-        )
-    else:
-        params = {"model_id": 5, "prompt": item.query}
-        response = requests.post(url, params=params)
-        if response.status_code != 200:
-            return f"Error status: {response.status_code}"
-        check_response = response.json()
-        answer = check_response.get("content")
-        return SuccessResponse(
-            status="True",
-            randydev={"message": answer}
-        )
-
-@app.post("/ryuzaki/chatgpt3-turbo", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def chatgpt3_turbo(item: Chatgpt3Texts):
-    if item.is_openai_original:
-        try:
-            GPTbase = SOURCE_OPENAI_ACCESS_URL
-            response = OpenAiToken(api_key=item.api_key, api_base=GPTbase).chat_message_turbo(
-                query=item.query,
-                model=item.model,
-                is_stream=item.is_stream
-            )
-            answer = response[0]
-            continue_chat = response[1]
-            return SuccessResponse(
-                status="True",
-                randydev={
-                    "message": answer,
-                    "chat_history": continue_chat
-                }
-            )
-        except Exception as e:
-            return SuccessResponse(status="False", randydev={"message": f"Error responding: {e}"})
-    else:
-        url = "https://lexica.qewertyy.me/models"
-        params = {"model_id": 5, "prompt": item.query}
-        response = requests.post(url, params=params)
-        if response.status_code != 200:
-            return f"Error status: {response.status_code}"
-        check_response = response.json()
-        answer = check_response.get("content")
-        return SuccessResponse(
-            status="True",
-            randydev={"message": answer}
-        )
-
-@app.post("/ryuzaki/chatgpt4-turbo", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def chatgpt4_turbo(
-    item: OpenaiTexts,
-    api_key: None = Depends(validate_api_key)
-):
-    try:
-        GPTbase = SOURCE_OPENAI_ACCESS_URL
-        response = OpenAiToken(api_key=item.api_key, api_base=GPTbase).chat_message_turbo(
-            query=item.query,
-            model=item.model,
-            is_stream=item.is_stream
-        )
-        if item.model == "gpt-5":
-            return SuccessResponse(status="False", randydev={"message": "Coming Soon in 2024"})
-        elif item.model == "gpt-5-turbo":
-            return SuccessResponse(status="False", randydev={"message": "Coming Soon in 2024"})
-        elif item.model == "gpt-5-plus":
-            return SuccessResponse(status="False", randydev={"message": "Coming Soon in 2024"})
-        answer = response[0]
-        continue_chat = response[1]
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "message": answer,
-                "chat_history": continue_chat
-            }
-        )
-    except Exception as e:
-        return SuccessResponse(status="False", randydev={"message": f"Error responding: {e}"})
-
-@app.post("/ryuzaki/google-ai", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def v1beta3_google_ai(
-    item: ChatgptCustom,
-    api_key: None = Depends(validate_api_key)
-):
-    url = SOURCE_ASSISTANT_GOOGLE_AI
-    token = ASSISTANT_GOOGLE_API_KEYS
-    api_url = f"{SOURCE_ASSISTANT_GOOGLE_AI}/v1beta3/models/text-bison-001:generateText?key={ASSISTANT_GOOGLE_API_KEYS}"
-    try:
-        headers = {"Content-Type": "application/json"}
-        data = {
-            "prompt": {
-                "text": item.query
+        return {
+            "status": "true",
+            "randydev":{
+                "message": response
             }
         }
-        response = requests.post(api_url, headers=headers, json=data)
-        response_str = response.json()
-        answer = response_str["candidates"]
-        for results in answer:
-            message = results.get("output")
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "message": message
-            }
-        )
     except:
         return {"status": "false", "message": "Error response."}
 
-#add too docker 	-e COOKIE_BARD_TOKEN="YOUR_VALUE_HERE" \
-#@app.post("/ryuzaki/gemini-ai-pro", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-#def gemini_pro(
-#    item: GeminiPro,
-#    api_key: None = Depends(validate_api_key)
-#):
-#    if item.is_login:
-#        token = item.bard_api_key
-#    else:
-#        token = COOKIE_BARD_TOKEN
-#    owner_base = f"""
-#    Your name is Randy Dev. A kind and friendly AI assistant that answers in
-#    a short and concise answer. Give short step-by-step reasoning if required.
-#
-#    Today is {dt.now():%A %d %B %Y %H:%M}
-#    """
-#    try:
-#        session = requests.Session()
-#        session.headers = {
-#            "Host": "bard.google.com",
-#            "X-Same-Domain": "1",
-#            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36",
-#            "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
-#            "Origin": "https://bard.google.com",
-#            "Referer": "https://bard.google.com/"
-#        }
-#        session.cookies.set("__Secure-1PSID", token)
-#        bard = Bard(token=token, session=session, timeout=30)
-#        bard.get_answer(owner_base)["content"]
-#        message = bard.get_answer(item.query)["content"]
-#        return SuccessResponse(
-#            status="True",
-#            randydev={
-#                "message": message
-#            }
-#        )
-#    except:
-#        return {"status": "false", "message": "Error response."}
-
-@app.post("/ryuzaki/v1beta2-google-ai", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def v1beta2_google_ai(
-    item: ChatgptCustom,
-    api_key: None = Depends(validate_api_key)
+@app.post("/ryuzaki/chatgpt-model")
+def chatgpt_model(
+    query: str=None,
+    model_id: int=1,
+    is_models: bool=True
 ):
-    url = SOURCE_ASSISTANT_GOOGLE_AI
-    token = ASSISTANT_GOOGLE_API_KEYS
-    api_url = f"{SOURCE_ASSISTANT_GOOGLE_AI}/v1beta2/models/chat-bison-001:generateMessage?key={ASSISTANT_GOOGLE_API_KEYS}"
     try:
-        headers = {"Content-Type": "application/json"}
-        data = {
-            "prompt": {
-                "messages": [{"content": item.query}]}
-        }
-        response = requests.post(api_url, headers=headers, json=data)
-        response_str = response.json()
-        answer = response_str["candidates"]
-        for results in answer:
-            message = results.get("content")
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "message": message
+        response = RendyDevChat(query).get_response_model(model_id=model_id, is_models=is_models)
+        return {
+            "status": "true",
+            "randydev":{
+                "message": response
             }
-        )
+        }
     except:
         return {"status": "false", "message": "Error response."}
 
-#@app.post("/ryuzaki/new-monitor", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-#def new_monitor(
-#    item: NewMonitor,
-#    api_key: None = Depends(validate_api_key)
-#):
-#    urls = SOURCE_MONITOR_URL
-#    token = MONITOR_API_KEYS
-#    api_url = f"{urls}/newMonitor"
-#    try:
-#        headers = {
-#            "content-type": "application/x-www-form-urlencoded",
-#            "cache-control": "no-cache"
-#        }
-#        payload = {
-#            "api_key": token,
-#            "format": "json",
-#            "type": item.type,
-#            "url": item.url,
-#            "friendly_name": item.friendly_name
-#        }
-#        response = requests.post(api_url, data=payload, headers=headers)
-#        response_str = response.json()
-#        status_ok = response_str["stat"]
-#        monitor_id = response_str["monitor"].get("id")
-#        monitor_status = response_str["monitor"].get("status")
-#        return {
-#            "status": "true",
-#            "randydev":{
-#                "status_ok": status_ok,
-#                "monitor_id": monitor_id,
-#                "monitor_status": monitor_status
-#            }
-#        }
-#    except:
-#        return {"status": "false", "message": "Error response."}
-
-#@app.post("/ryuzaki/get-monitors", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
-#def getMonitors(
-#    item: GetMonitorLogs,
-#    api_key: None = Depends(validate_api_key)
-#):
-#    url = SOURCE_MONITOR_URL
-#    token = MONITOR_API_KEYS
-#    api_url = f"{url}/getMonitors"
-#    try:
-#        headers = {
-#            "content-type": "application/x-www-form-urlencoded",
-#            "cache-control": "no-cache"
-#        }
-#        payload = {
-#            "api_key": token,
-#            "format": "json",
-#            "logs": item.logs
-#        }
-#        response = requests.post(api_url, data=payload, headers=headers)
-#        response_str = response.json()
-#        data = response_str["monitors"]
-#        url_list = []
-#        for x in data:
-#            url = x.get("url")
-#            if url:
-#                url_list.append(url)
-#        return {
-#            "status": "true",
-#            "randydev":{
-#                "url": url_list,
-#            }
-#        }
-#    except:
-#        return {"status": "false", "message": "Error response."}
-
 async def get_data(username):
     base_msg = ""
     async with AsyncClient() as gpx:
@@ -882,10 +368,10 @@ async def get_data(username):
             base_msg += f"**An error occured while parsing the data!** \n\n**Traceback:** \n `{e}` \n\n`Make sure that you've sent the command with the correct username!`"
             return [base_msg, "https://telegra.ph//file/32f69c18190666ea96553.jpg"]
 
-@app.get("/ryuzaki/github", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-async def github(item: GithubUsernames):
+@app.get("/ryuzaki/github")
+async def github(username: str=None):
     try:
-        details = await get_data(item.username)
+        details = await get_data(username)
         return {
             "status": "true",
             "randydev":{
@@ -896,10 +382,16 @@ async def github(item: GithubUsernames):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/webshot", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def webshot(item: Webshot):
+@app.get("/ryuzaki/webshot")
+def webshot(
+    url: str=None,
+    quality: str="1920x1080",
+    type_mine: str="JPEG",
+    pixels: str="1024",
+    cast: str="Z100"
+):
     try:
-        required_url = f"https://mini.s-shot.ru/{item.quality}/{item.type_mine}/{item.pixels}/{item.cast}/?{item.url}"
+        required_url = f"https://mini.s-shot.ru/{quality}/{type_mine}/{pixels}/{cast}/?{url}"
         return {
             "status": "true",
             "randydev":{
@@ -909,14 +401,19 @@ def webshot(item: Webshot):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/chatbot", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def chatbot(item: ChatBots):
+@app.get("/ryuzaki/chatbot")
+def chatbot(
+    query: str=None,
+    user_id: int=None,
+    bot_name: str=None,
+    bot_username: str=None
+):
     api_url = b64decode("aHR0cHM6Ly9hcGkuc2Fmb25lLmRldi9jaGF0Ym90").decode("utf-8")
     params = {
-        "query": item.query,
-        "user_id": item.user_id,
-        "bot_name": item.bot_name,
-        "bot_master": item.bot_username
+        "query": query,
+        "user_id": user_id,
+        "bot_name": bot_name,
+        "bot_master": bot_username
     }
     x = requests.get(f"{api_url}", params=params)
     if x.status_code != 200:
@@ -933,29 +430,13 @@ def chatbot(item: ChatBots):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/llama", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def get_llama(item: ChatgptCustom):
-    api_url = SOURCE_WHAT_GAY_URL
-    params = {"query": item.query}
-    x = requests.get(f"{api_url}/llama", params=params)
-    if x.status_code != 200:
-        return "Error api request"
-    try:
-        y = x.json()
-        response = y["answer"]
-        return {
-            "status": "true",
-            "randydev":{
-                "message": response
-            }
-        }
-    except:
-        return {"status": "false", "message": "Error response."}
-
-@app.get("/ryuzaki/waifu", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def waifu_pics(item: WaifuPics):
-    waifu_api = f"{SOURCE_WAIFU_URL}/{item.types}"
-    waifu_param = f"{waifu_api}/{item.category}"
+@app.get("/ryuzaki/waifu")
+def waifu_pics(
+    types: str="sfw",
+    category: str="neko"
+):
+    waifu_api = f"{SOURCE_WAIFU_URL}/{types}"
+    waifu_param = f"{waifu_api}/{category}"
 
     response = requests.get(waifu_param)
 
@@ -967,40 +448,42 @@ def waifu_pics(item: WaifuPics):
     except Exception as e:
         return f"Error request {e}"
     if waifu_image_url:
-        if item.is_bytes:
-            try:
-                response_two = requests.get(waifu_image_url)
-                response_two.raise_for_status()
-            except requests.exceptions.RequestException:
-                raise HTTPException(status_code=500, detail="Internal server error")
-            return StreamingResponse(BytesIO(response_two.content), media_type=item.media_type)
-        else:
+        try:
             return {
                 "status": "true",
                 "randydev":{
                     "image_url": waifu_image_url
                 }
             }
+        except:
+            return {"status": "false", "message": "Error response"}
     else:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/rayso", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def make_rayso(item: MakeRayso):
+@app.get("/ryuzaki/rayso")
+def make_rayso(
+    code=None,
+    title: str="Ryuzaki Dev",
+    theme: str=None,
+    setlang: str="en",
+    auto_translate: bool=None,
+    ryuzaki_dark: bool=None
+):
     trans = SyncTranslator()
     api_url = b64decode("aHR0cHM6Ly9hcGkuc2Fmb25lLm1lL3JheXNv").decode("utf-8")
-    if item.auto_translate:
-        source = trans.detect(item.code)
-        translation = trans(item.code, sourcelang=source, targetlang=item.setlang)
+    if auto_translate:
+        source = trans.detect(code)
+        translation = trans(code, sourcelang=source, targetlang=setlang)
         code = translation.text
     else:
-        code = item.code
-    if item.ryuzaki_dark:
+        code = code
+    if ryuzaki_dark:
         x = requests.post(
             f"{api_url}",
             json={
                 "code": code,
-                "title": item.title,
-                "theme": item.theme,
+                "title": title,
+                "theme": theme,
                 "darkMode": True
             }
         )
@@ -1022,8 +505,8 @@ def make_rayso(item: MakeRayso):
             f"{api_url}",
             json={
                 "code": code,
-                "title": item.title,
-                "theme": item.theme,
+                "title": title,
+                "theme": theme,
                 "darkMode": False
             }
         )
@@ -1088,11 +571,11 @@ def whois_ip_address(ip_address: str=None):
     else:
         return {"status": "false", "message": "Invalid ip address"}
 
-@app.get("/ryuzaki/tiktok_douyin", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def tiktok_douyin(item: TiktokDownloader):
-    response = requests.get(f"{SOURCE_TIKTOK_WTF_URL}={item.tiktok_url}")
+@app.get("/ryuzaki/tiktok_douyin")
+def tiktok_douyin(tiktok_url: str=None):
+    response = requests.get(f"{SOURCE_TIKTOK_WTF_URL}={tiktok_url}")
     if response.status_code != 200:
-        return "Internal server error"
+        return "Error request:"
     try:
         download_video = response.json()["aweme_list"][0]["video"]["play_addr"]["url_list"][0]
         download_audio = response.json()["aweme_list"][0]["music"]["play_url"]["url_list"][0]
@@ -1112,10 +595,10 @@ def tiktok_douyin(item: TiktokDownloader):
     except:
         return {"status": "false", "message": "Error request"}
 
-@app.get("/ryuzaki/tiktok", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-def tiktok_downloader(item: TiktokBeta):
+@app.get("/ryuzaki/tiktok")
+def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None):
     api_devs = SOURCE_TIKTOK_TECH_URL
-    parameter = f"tiktok?url={item.tiktok_url}"
+    parameter = f"tiktok?url={tiktok_url}"
     api_url = f"{api_devs}/{parameter}"
     response = requests.get(api_url)
 
@@ -1124,7 +607,7 @@ def tiktok_downloader(item: TiktokBeta):
     try:
         results = response.json()
         caption = results.get("result", {}).get("desc", "")
-        if item.only_video:
+        if only_video:
             video_url = results.get("result", {}).get("withoutWaterMarkVideo", "")
             if video_url:
                 return {
@@ -1143,170 +626,190 @@ def tiktok_downloader(item: TiktokBeta):
         return {"status": "false", "message": "Invalid Link"}
 
 @app.get("/ryuzaki/mediafire")
-def mediafire(item: DownloadLink):
-    try:
-        down_link = str(item.link)
-        mid = down_link.split('/', 5)
-        if mid[3] == "view":
-            mid[3] = "file"
-            down_link = '/'.join(mid)
-        r = requests.get(down_link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"class": "input popsok"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 5)[4]
-        a_byte = soup.find("a", {"class": "input popsok"}).get_text()
-        a_name = soup.find("div", {"class": "dl-btn-label"}).get_text()
-        details = soup.find("ul", {"class": "details"})
-        li_items = details.find_all('li')[1]
-        some = li_items.find_all("span")[0].get_text().split()
-        dat = list(some)
-        down = a_byte.replace(" ", "").strip()
-        time = dat[1]
-        date = dat[0]
-        byte = down.split("(", 1)[1].split(")", 1)[0]
-        name = a_name.replace(" ", "").strip()
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "directDownload": a,
-                "original": item.link,
-                "id": id,
-                "name": name,
-                "readable": byte,
-                "time": byte,
-                "date": date
+def mediafire(link: Union[str, None] = None):
+  try:
+    down_link = str(link)
+    mid = down_link.split('/', 5)
+    if mid[3] == "view":
+      mid[3] = "file"
+      down_link = '/'.join(mid)
+      print(down_link)
+    r = requests.get(down_link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"class": "input popsok"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 5)[4]
+    a_byte = soup.find("a", {"class": "input popsok"}).get_text()
+    a_name = soup.find("div", {"class": "dl-btn-label"}).get_text()
+    details = soup.find("ul", {"class": "details"})
+    li_items = details.find_all('li')[1]
+    some = li_items.find_all("span")[0].get_text().split()
+    dat = list(some)
+    down = a_byte.replace(" ", "").strip()
+    time = dat[1]
+    date = dat[0]
+    byte = down.split("(", 1)[1].split(")", 1)[0]
+    name = a_name.replace(" ", "").strip()
+    return {
+      "status": "true",
+      "data": {
+        "file": {
+          "url": {
+            'directDownload': a,
+            "original": link,
+          },
+          "metadata": {
+            "id": id,
+            "name": name,
+            "size": {
+              "readable": byte
+            },
+            "DateAndTime": {
+              "time": time,
+              "date": date
             }
-        )
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
+          }
+        }
+      }
+    }
+
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
+
 
 @app.get("/ryuzaki/gdrive")
-def gdrive(item: DownloadLink):
-    try:
-        down = link.split('/', 6)
-        url = f'https://drive.google.com/uc?export=download&id={down[5]}'
-        session = requests.Session()
-        response = session.get(url, stream=True)
-        headers = response.headers
-        content_disp = headers.get('content-disposition')
-        filename = None
-        if content_disp:
-            match = re.search(r'filename="(.+)"', content_disp)
-            if match:
-                filename = match.group(1)
-        content_length = headers.get('content-length')
-        last_modified = headers.get('last-modified')
-        content_type = headers.get('content-type')
-        return SuccessResponse(
-            status="True",
-            randydev={
-                "directDownload": url,
-                "original": item.link,
-                "id": down[5],
-                "name": filename if filename else "No filename provided by the server.",
-                "readable": f"{round(int(content_length) / (1024 * 1024), 2)} MB" if content_length else "No content length provided by the server.",
-                "type": content_type if content_type else "No content type provided by the server.",
-                "DateAndTime": last_modified if last_modified else "No last modified date provided by the server."
-            }
-        )
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
+def gdrive(link: Union[str, None] = None):
+  try:
+    down = link.split('/', 6)
+    url = f'https://drive.google.com/uc?export=download&id={down[5]}'
+    session = requests.Session()
+
+    response = session.get(url, stream=True)
+    headers = response.headers
+    content_disp = headers.get('content-disposition')
+    filename = None
+    if content_disp:
+      match = re.search(r'filename="(.+)"', content_disp)
+      if match:
+        filename = match.group(1)
+
+    content_length = headers.get('content-length')
+    last_modified = headers.get('last-modified')
+    content_type = headers.get('content-type')
+
+    return {
+      "status": "true",
+      "data": {
+        "file": {
+          "url": {
+            'directDownload': url,
+            "original": link,
+          },
+          "metadata": {
+            "id":
+            down[5],
+            "name":
+            filename if filename else 'No filename provided by the server.',
+            "size": {
+              "readable":
+              f'{round(int(content_length) / (1024 * 1024), 2)} MB' if
+              content_length else 'No content length provided by the server.',
+              "type":
+              content_type
+              if content_type else 'No content type provided by the server.'
+            },
+            "DateAndTime":
+            last_modified if last_modified else
+            'No last modified date provided by the server.',
+          }
+        }
+      }
+    }
+
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
 
 @app.get("/ryuzaki/anonfiles")
-def anonfiles(item: DownloadLink):
-    try:
-        r = requests.get(item.link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"id": "download-url"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 4)[3]
-        jsondata = requests.get(f'https://api.anonfiles.com/v2/file/{id}/info').json()
-        jsondata['data']['file']['url']['directDownload'] = a
-        del jsondata['data']['file']['url']['full']
-        return jsondata
-    except:
-        return "{'status': 'false', 'message': 'Invalid Link'}"
+def anonfiles(link: Union[str, None] = None):
+  try:
+    r = requests.get(link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"id": "download-url"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 4)[3]
+    jsondata = requests.get(
+      f'https://api.anonfiles.com/v2/file/{id}/info').json()
+    jsondata['data']['file']['url']['directDownload'] = a
+    del jsondata['data']['file']['url']['full']
+
+    return jsondata
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
 
 @app.get("/ryuzaki/filechan")
-def filechan(item: DownloadLink):
-    try:
-        r = requests.get(item.link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"id": "download-url"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 4)[3]
-        jsondata = requests.get(f'https://api.filechan.org/v2/file/{id}/info').json()
-        jsondata['data']['file']['url']['directDownload'] = a
-        del jsondata['data']['file']['url']['full']
-        return jsondata
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
+def filechan(link: Union[str, None] = None):
+  try:
+    r = requests.get(link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"id": "download-url"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 4)[3]
+    jsondata = requests.get(
+      f'https://api.filechan.org/v2/file/{id}/info').json()
+    jsondata['data']['file']['url']['directDownload'] = a
+    del jsondata['data']['file']['url']['full']
+
+    return jsondata
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
 
 @app.get("/ryuzaki/letsupload")
-def letsupload(item: DownloadLink):
-    try:
-        r = requests.get(item.link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"id": "download-url"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 4)[3]
-        jsondata = requests.get(f'https://api.letsupload.cc/v2/file/{id}/info').json()
-        jsondata['data']['file']['url']['directDownload'] = a
-        del jsondata['data']['file']['url']['full']
-        return jsondata
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
+def letsupload(link: Union[str, None] = None):
+  try:
+    r = requests.get(link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"id": "download-url"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 4)[3]
+    jsondata = requests.get(
+      f'https://api.letsupload.cc/v2/file/{id}/info').json()
+    jsondata['data']['file']['url']['directDownload'] = a
+    del jsondata['data']['file']['url']['full']
+
+    return jsondata
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
 
 @app.get("/ryuzaki/megaupload")
-def megaupload(item: DownloadLink):
-    try:
-        r = requests.get(item.link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"id": "download-url"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 4)[3]
-        jsondata = requests.get(f'https://api.megaupload.nz/v2/file/{id}/info').json()
-        jsondata['data']['file']['url']['directDownload'] = a
-        del jsondata['data']['file']['url']['full']
-        return jsondata
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
+def megaupload(link: Union[str, None] = None):
+  try:
+    r = requests.get(link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"id": "download-url"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 4)[3]
+    jsondata = requests.get(
+      f'https://api.megaupload.nz/v2/file/{id}/info').json()
+    jsondata['data']['file']['url']['directDownload'] = a
+    del jsondata['data']['file']['url']['full']
+
+    return jsondata
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"
 
 @app.get("/ryuzaki/myfile")
-def myfile(item: DownloadLink):
-    try:
-        r = requests.get(item.link)
-        soup = BeautifulSoup(r.content, "html.parser")
-        a_href = soup.find("a", {"id": "download-url"}).get("href")
-        a = str(a_href)
-        id = link.split('/', 4)[3]
-        jsondata = requests.get(f'https://api.myfile.is/v2/file/{id}/info').json()
-        jsondata['data']['file']['url']['directDownload'] = a
-        del jsondata['data']['file']['url']['full']
-        return jsondata
-    except:
-        return {'status': 'false', 'message': 'Invalid Link'}
-
-description = """
-- Ryuzaki Library: [Library Here](https://github.com/TeamKillerX/RyuzakiLib)
-
-•Developed by [@xtdevs](https://t.me/xtdevs)
-"""
-def custom_openapi():
-    if app.openapi_schema:
-        return app.openapi_schema
-    openapi_schema = get_openapi(
-        title="RyuzakiLib API",
-        version="2.2.1",
-        summary="Use It Only For Personal Project Else I Need To Delete The Api",
-        description=description,
-        routes=app.routes,
-    )
-    openapi_schema["info"]["x-logo"] = {
-        "url": "https://github-production-user-asset-6210df.s3.amazonaws.com/90479255/289277800-f26513f7-cdf4-44ee-9a08-f6b27e6b99f7.jpg"
-    }
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-app.openapi = custom_openapi
+def myfile(link: Union[str, None] = None):
+  try:
+    r = requests.get(link)
+    soup = BeautifulSoup(r.content, "html.parser")
+    a_href = soup.find("a", {"id": "download-url"}).get("href")
+    a = str(a_href)
+    id = link.split('/', 4)[3]
+    jsondata = requests.get(
+      f'https://api.myfile.is/v2/file/{id}/info').json()
+    jsondata['data']['file']['url']['directDownload'] = a
+    del jsondata['data']['file']['url']['full']
+
+    return jsondata
+  except:
+    return "{'status': 'false', 'message': 'Invalid Link'}"

requirements.txt

@@ -1,8 +1,8 @@
 requests
 pymongo
 bs4
-git+https://github.com/TeamKillerX/RyuzakiLib
-openai==0.28.0
+g4f
+RyuzakiLib
 uvicorn
 gpytranslate
 google-search-results
@@ -24,4 +24,3 @@ typing-extensions
 uvicorn[standard]
 uvloop
 stripe
-bardapi