api update

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,8 +1,10 @@
 ---
-title: UFoP Api
+title: Ryuzaki Api
 emoji: 📈
-colorFrom: red
-colorTo: blue
+colorFrom: pink
+colorTo: purple
 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,17 +25,19 @@ 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 Union
+from typing import *
 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
@@ -47,9 +49,10 @@ from telegraph import Telegraph, upload_file
 from pathlib import Path
 from serpapi import GoogleSearch
 
-from fastapi import FastAPI, UploadFile, File
+from fastapi import FastAPI, UploadFile, File, Response
 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
@@ -58,50 +61,70 @@ 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.spamwatch.clients import SibylBan
+from RyuzakiLib.system import OpenReadSystem
+
+from bardapi import Bard
+
+from models import *
+
+from gpytranslate import SyncTranslator
 
 import logging
-import database as db
 import functions as code
 
 logging.basicConfig(level=logging.ERROR)
 
-# I DON'T KNOW LIKE THIS HACKER
+
 load_dotenv()
-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"]
+
+# Database url
+MONGO_URL = os.environ["MONGO_URL"]
+
+# source url
 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_WAIFU_URL = "https://api.waifu.pics"
+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_TIKTOK_WTF_URL = os.environ["SOURCE_TIKTOK_WTF_URL"]
 SOURCE_TIKTOK_TECH_URL = os.environ["SOURCE_TIKTOK_TECH_URL"]
-DEVELOPER_ID = os.environ["DEVELOPER_ID"]
+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"]
 
-description = """
-~ Developed written and powered by
-- Ryuzaki Library: [Library Here](https://github.com/TeamKillerX/RyuzakiLib)
-"""
+# 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"]
 
-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="/"
-)
+trans = SyncTranslator()
+
+app = FastAPI(docs_url=None, redoc_url="/")
+
+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
 
 def validate_api_key(api_key: str = Header(...)):
-    USERS_API_KEYS = db.get_all_api_keys()
+    USERS_API_KEYS = get_all_api_keys()
     if api_key not in USERS_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
@@ -109,10 +132,151 @@ 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({})
 
-@app.get("/UFoP/getbanlist")
+    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("/ryuzaki/getbanlist")
 def sibyl_get_all_banlist():
-    banned_users = db.get_all_banned()
+    banned_users = get_all_banned()
     return {
         "status": "True",
         "randydev": {
@@ -120,7 +284,7 @@ def sibyl_get_all_banlist():
         }
     }
 
-@app.get("/UFoP/blacklist-words")
+@app.get("/ryuzaki/blacklist-words")
 def blacklist_words():
     try:
         BLACKLIST_WORDS = BadWordsList()
@@ -129,128 +293,130 @@ def blacklist_words():
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.delete("/UFoP/bandel")
+@app.delete("/ryuzaki/sibyldel", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system_delete(
-    user_id: int = Query(..., description="User ID in query parameter only developer"),
+    item: SibylSystemDel,
     api_key: None = Depends(validate_api_key_only_devs)
 ):
     try:
-        _, _, _, _, sibyl_user_id = db.get_sibyl_system_banned(user_id)
+        _, _, _, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
 
         if sibyl_user_id:
-            db.remove_sibyl_system_banned(user_id)
-            return {"status": "true", "message": f"Successfully removed {user_id} from the Sibyl ban list."}
+            remove_sibyl_system_banned(item.user_id)
+            return SuccessResponse(
+                status="True",
+                randydev={"message": f"Successfully removed {item.user_id} from the Sibyl ban list"}
+            )
         else:
-            return {"status": "false", "message": "Not found user"}
+            return SuccessResponse(
+                status="False",
+                randydev={"message": "Not Found UserID"}
+            )
     except Exception as e:
-        return {"status": "false", "message": f"Internal server error: {str(e)}"}
+        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-@app.post("/UFoP/banner")
+@app.post("/ryuzaki/sibylban", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system_ban(
-    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)
+    item: SibylSystemBan,
+    api_key: None = Depends(validate_api_key)
 ):
-    if user_id == int(DEVELOPER_ID):
+    if item.user_id == 1191668125:
         return {"status": "false", "message": "Only Developer"}
 
     try:
         date_joined = str(dt.now())
-        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"}
+        sibyl_ban = random.choice(RAMDOM_STATUS)
+        _, _, is_banned, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
 
-        db.new_sibyl_system_banned(user_id, sibyl_ban, reason, date_joined)
+        if sibyl_user_id and is_banned:
+            return {"status": "false", "message": "User is already banned"}
 
-        return {
-            "status": "true",
-            "randydev": {
-                "user_id": user_id,
+        new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
+        return SuccessResponse(
+            status="True",
+            randydev={
+                "user_id": item.user_id,
                 "sibyl_name": sibyl_ban,
-                "reason": reason,
+                "reason": item.reason,
                 "date_joined": date_joined,
-                "message": f"Successfully banned {user_id} from the Sibyl ban list."
+                "message": f"Successfully banned {item.user_id} from the Sibyl ban list."
             }
-        }
+        )
     except Exception as e:
-        logging.error(f"Error in sibyl_system_ban: {e}")
-        return {"status": "false", "message": "Internal server error"}
+        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-@app.get("/UFoP/bans")
+@app.get("/ryuzaki/sibyl", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system(
-    user_id: int = Query(..., description="User ID in query parameter"),
-    api_key: None = Depends(validate_api_key) or Depends(validate_api_key_only_devs)
+    item: SibylSystem,
+    api_key: None = Depends(validate_api_key)
 ):
-    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_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={
                 "sibyl_name": sibyl_name,
                 "reason": reason,
                 "is_banned": is_banned,
                 "date_joined": date_joined,
                 "sibyl_user_id": sibyl_user_id
             }
-        }
+        )
     else:
-        return {"status": "false", "message": "Not Found User"}
+        return SuccessResponse(
+            status="false",
+            randydev={
+                "message": "Not found user"
+            }
+        )
 
-@app.get("/ryuzaki/ai")
-def ryuzaki_ai(
-    text: str = Query(..., description="text in query parameter"),
-    api_key: None = Depends(validate_api_key_only_devs)
+@app.get("/ryuzaki/pypi-search", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def pypi_search(
+    item: TextCustom,
 ):
     try:
-        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}"
+        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"})
 
+@app.get("/ryuzaki/translate", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def get_translate(
+    item: TranslateCustom,
+):
     try:
-        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}")
-
-    return StreamingResponse(BytesIO(response.content), media_type="image/jpeg")
+        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"})
 
-@app.get("/ryuzaki/reverse")
+@app.get("/ryuzaki/reverse", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def google_reverse(
-    engine: str="google_reverse_image",
-    image_url: str=None,
-    language: str="en",
-    google_lang: str="us",
+    item: GoogleReverse,
     api_key: None = Depends(validate_api_key)
 ):
     params = {
         "api_key": REVERSE_IMAGE_API,
-        "engine": engine,
-        "image_url": image_url,
-        "hl": language,
-        "gl": google_lang
+        "engine": item.engine,
+        "image_url": item.image_url,
+        "hl": item.language,
+        "gl": item.google_lang
     }
     try:
         search = GoogleSearch(params)
@@ -259,30 +425,28 @@ 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 {
-            "status": "true",
-            "randydev": {
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "link": link,
                 "total_time_taken": total_time_taken,
                 "create_at": create_at,
                 "processed_at": processed_at
             }
-        }
-    except Exception as e:
-        return {"status": "false", "message": f"Error {e}"}
+        )
+    except Exception:
+        return {"status": "false", "message": "Internal server error"}
 
-@app.get("/ryuzaki/ocr")
+@app.get("/ryuzaki/ocr", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def ocr_space_url(
-    url: str = Query(..., description="URL in query parameter"),
-    overlay: bool=False,
-    language: str = Query("eng", description="Language in query parameter"),
+    item: OrcSpaceUrl,
     api_key: None = Depends(validate_api_key)
 ):
     payload = {
-        "url": url,
-        "isOverlayRequired": overlay,
+        "url": item.url,
+        "isOverlayRequired": item.overlay,
         "apikey": OCR_API_KEY,
-        "language": language
+        "language": item.language
     }
     try:
         response = requests.post(SOURCE_OCR_URL, data=payload)
@@ -293,53 +457,403 @@ def ocr_space_url(
     try:
         parsed_response = json.loads(test_url)
         if "ParsedResults" in parsed_response and len(parsed_response["ParsedResults"]) > 0:
-            return {
-                "status": "true",
-                "randydev":{
+            return SuccessResponse(
+                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/chatgpt4")
-def chatgpt4_support(
-    query: str=None,
+@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,
     api_key: None = Depends(validate_api_key)
 ):
+    API_URL = SOURCE_OPENDALLE_URL
     try:
-        response = g4f.ChatCompletion.create(
-            model=g4f.models.gpt_4,
-            messages=[{"role": "user", "content": query}],
+        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=[{}])
         )
-        return {
-            "status": "true",
-            "randydev":{
-                "message": response
+    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/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
             }
         }
+        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."}
 
-@app.post("/ryuzaki/chatgpt-model")
-def chatgpt_model(
-    query: str=None,
-    model_id: int=1,
-    is_models: bool=True
+#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)
 ):
+    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:
-        response = RendyDevChat(query).get_response_model(model_id=model_id, is_models=is_models)
-        return {
-            "status": "true",
-            "randydev":{
-                "message": response
-            }
+        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
+            }
+        )
     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:
@@ -368,10 +882,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")
-async def github(username: str=None):
+@app.get("/ryuzaki/github", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+async def github(item: GithubUsernames):
     try:
-        details = await get_data(username)
+        details = await get_data(item.username)
         return {
             "status": "true",
             "randydev":{
@@ -382,16 +896,10 @@ async def github(username: str=None):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/webshot")
-def webshot(
-    url: str=None,
-    quality: str="1920x1080",
-    type_mine: str="JPEG",
-    pixels: str="1024",
-    cast: str="Z100"
-):
+@app.get("/ryuzaki/webshot", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def webshot(item: Webshot):
     try:
-        required_url = f"https://mini.s-shot.ru/{quality}/{type_mine}/{pixels}/{cast}/?{url}"
+        required_url = f"https://mini.s-shot.ru/{item.quality}/{item.type_mine}/{item.pixels}/{item.cast}/?{item.url}"
         return {
             "status": "true",
             "randydev":{
@@ -401,19 +909,14 @@ def webshot(
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/chatbot")
-def chatbot(
-    query: str=None,
-    user_id: int=None,
-    bot_name: str=None,
-    bot_username: str=None
-):
+@app.get("/ryuzaki/chatbot", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def chatbot(item: ChatBots):
     api_url = b64decode("aHR0cHM6Ly9hcGkuc2Fmb25lLmRldi9jaGF0Ym90").decode("utf-8")
     params = {
-        "query": query,
-        "user_id": user_id,
-        "bot_name": bot_name,
-        "bot_master": bot_username
+        "query": item.query,
+        "user_id": item.user_id,
+        "bot_name": item.bot_name,
+        "bot_master": item.bot_username
     }
     x = requests.get(f"{api_url}", params=params)
     if x.status_code != 200:
@@ -430,13 +933,29 @@ def chatbot(
     except:
         return {"status": "false", "message": "Error response."}
 
-@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}"
+@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}"
 
     response = requests.get(waifu_param)
 
@@ -448,42 +967,40 @@ def waifu_pics(
     except Exception as e:
         return f"Error request {e}"
     if waifu_image_url:
-        try:
+        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:
             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")
-def make_rayso(
-    code=None,
-    title: str="Ryuzaki Dev",
-    theme: str=None,
-    setlang: str="en",
-    auto_translate: bool=None,
-    ryuzaki_dark: bool=None
-):
+@app.get("/ryuzaki/rayso", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def make_rayso(item: MakeRayso):
     trans = SyncTranslator()
     api_url = b64decode("aHR0cHM6Ly9hcGkuc2Fmb25lLm1lL3JheXNv").decode("utf-8")
-    if auto_translate:
-        source = trans.detect(code)
-        translation = trans(code, sourcelang=source, targetlang=setlang)
+    if item.auto_translate:
+        source = trans.detect(item.code)
+        translation = trans(item.code, sourcelang=source, targetlang=item.setlang)
         code = translation.text
     else:
-        code = code
-    if ryuzaki_dark:
+        code = item.code
+    if item.ryuzaki_dark:
         x = requests.post(
             f"{api_url}",
             json={
                 "code": code,
-                "title": title,
-                "theme": theme,
+                "title": item.title,
+                "theme": item.theme,
                 "darkMode": True
             }
         )
@@ -505,8 +1022,8 @@ def make_rayso(
             f"{api_url}",
             json={
                 "code": code,
-                "title": title,
-                "theme": theme,
+                "title": item.title,
+                "theme": item.theme,
                 "darkMode": False
             }
         )
@@ -571,11 +1088,11 @@ def whois_ip_address(ip_address: str=None):
     else:
         return {"status": "false", "message": "Invalid ip address"}
 
-@app.get("/ryuzaki/tiktok_douyin")
-def tiktok_douyin(tiktok_url: str=None):
-    response = requests.get(f"{SOURCE_TIKTOK_WTF_URL}={tiktok_url}")
+@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}")
     if response.status_code != 200:
-        return "Error request:"
+        return "Internal server error"
     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]
@@ -595,10 +1112,10 @@ def tiktok_douyin(tiktok_url: str=None):
     except:
         return {"status": "false", "message": "Error request"}
 
-@app.get("/ryuzaki/tiktok")
-def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None):
+@app.get("/ryuzaki/tiktok", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+def tiktok_downloader(item: TiktokBeta):
     api_devs = SOURCE_TIKTOK_TECH_URL
-    parameter = f"tiktok?url={tiktok_url}"
+    parameter = f"tiktok?url={item.tiktok_url}"
     api_url = f"{api_devs}/{parameter}"
     response = requests.get(api_url)
 
@@ -607,7 +1124,7 @@ def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None
     try:
         results = response.json()
         caption = results.get("result", {}).get("desc", "")
-        if only_video:
+        if item.only_video:
             video_url = results.get("result", {}).get("withoutWaterMarkVideo", "")
             if video_url:
                 return {
@@ -626,190 +1143,170 @@ def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None
         return {"status": "false", "message": "Invalid Link"}
 
 @app.get("/ryuzaki/mediafire")
-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
+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
             }
-          }
-        }
-      }
-    }
-
-  except:
-    return "{'status': 'false', 'message': 'Invalid Link'}"
-
+        )
+    except:
+        return {'status': 'false', 'message': 'Invalid Link'}
 
 @app.get("/ryuzaki/gdrive")
-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'}"
+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'}
 
 @app.get("/ryuzaki/anonfiles")
-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'}"
+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'}"
 
 @app.get("/ryuzaki/filechan")
-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'}"
+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'}
 
 @app.get("/ryuzaki/letsupload")
-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'}"
+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'}
 
 @app.get("/ryuzaki/megaupload")
-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'}"
+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'}
 
 @app.get("/ryuzaki/myfile")
-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'}"
+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

models.py

@@ -0,0 +1,141 @@
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel
+
+class CustomErrorResponseModel(BaseModel):
+    detail: List[Dict[str, Any]]
+
+class SuccessResponse(BaseModel):
+    status: str
+    randydev: Dict[str, Any]
+
+class ErrorResponse(BaseModel):
+    status: str
+    detail: str
+
+class ErrorStatus(BaseModel):
+    status: str
+    message: str
+
+class ProfileClone(BaseModel):
+    user_id: int
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    profile_id: Optional[str] = None
+    bio: Optional[str] = None
+
+class GetProfileClone(BaseModel):
+    user_id: int
+
+class SibylSystemDel(BaseModel):
+    user_id: int
+
+class SibylSystemBan(BaseModel):
+    user_id: int
+    reason: str
+
+class RyuzakiAi(BaseModel):
+    text: str
+
+class SibylSystem(BaseModel):
+    user_id: int
+
+class SibylSystemResponse(BaseModel):
+    sibyl_name: str
+    reason: str
+    is_banned: bool
+    date_joined: str
+    sibyl_user_id: int
+
+class GoogleReverse(BaseModel):
+    engine: str="google_reverse_image"
+    image_url: str
+    language: str="en"
+    google_lang: str="us"
+
+class GetImageUnsplash(BaseModel):
+    query: str
+    size: str="500x500"
+
+class OrcSpaceUrl(BaseModel):
+    url: str
+    overlay: bool=False
+    language: str="eng"
+
+class ChatgptModel(BaseModel):
+    query: str
+    model_id: Optional[int] = None
+    is_models: bool=False
+
+class ChatgptCustom(BaseModel):
+    query: str
+
+class GeminiPro(BaseModel):
+    query: str
+    bard_api_key: Optional[str] = None
+    is_login: bool=False
+
+class WaifuPics(BaseModel):
+    types: str="sfw"
+    category: str="neko"
+    media_type: Optional[str] = None
+    is_bytes: bool=False
+
+class MakeRayso(BaseModel):
+    code: str
+    title: str="Ryuzaki Dev"
+    theme: str
+    setlang: str="en"
+    auto_translate: Optional[bool] = None
+    ryuzaki_dark: bool=True
+
+class Webshot(BaseModel):
+    url: str
+    quality: str="1920x1080"
+    type_mine: str="JPEG"
+    pixels: str="1024"
+    cast: str="Z100"
+
+class GithubUsernames(BaseModel):
+    username: str
+
+class ChatBots(BaseModel):
+    query: str
+    user_id: Optional[int] = None
+    bot_name: Optional[str] = None
+    bot_username: Optional[str] = None
+
+class TiktokBeta(BaseModel):
+    tiktok_url: str
+    only_video: Optional[bool] = None
+
+class TiktokDownloader(BaseModel):
+    tiktok_url: str
+
+class DownloadLink(BaseModel):
+    link: str
+
+class OpenDalle(BaseModel):
+    query: str
+
+class TranslateCustom(BaseModel):
+    text: str
+    setlang: str
+
+class AnimeStyled(BaseModel):
+    query: str
+
+class OpenaiTexts(BaseModel):
+    query: str
+    api_key: Optional[str] = ""
+    model: Optional[str] = "gpt-4"
+    is_stream: Optional[bool] = False
+
+class Chatgpt3Texts(BaseModel):
+    query: str
+    api_key: Optional[str] = ""
+    model: Optional[str] = "gpt-3.5-turbo"
+    is_stream: Optional[bool] = False
+    is_openai_original: Optional[bool] = False
+
+class TextCustom(BaseModel):
+    query: str

requirements.txt

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