sorts

functions.py

@@ -17,14 +17,16 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-import requests
 import os
+
+import requests
 from dotenv import load_dotenv
 
 load_dotenv()
 HUGGING_TOKEN = os.environ["HUGGING_TOKEN"]
 SOURCE_ALPHA_URL = os.environ["SOURCE_ALPHA_URL"]
 
+
 def ryuzaki_ai_text(text):
     API_URL = SOURCE_ALPHA_URL
     headers = {"Authorization": f"Bearer {HUGGING_TOKEN}"}

main.py

@@ -17,61 +17,33 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-import uvicorn
-import tempfile
-import shutil
-import requests
-import re
-import random
-import os
-import openai
-import logging
-import json
-import io
-import g4f
-import functions as code
 import base64
-
-from typing_extensions import Annotated
-from typing import Union
-from typing import Optional, List, Dict, Any
-from typing import Annotated, Union
-from typing import *
-
-from telegraph import Telegraph, upload_file
-from serpapi import GoogleSearch
-from random import choice
-from pymongo import MongoClient
-from pydantic import BaseModel
-from pathlib import Path
-from models import *
-from io import BytesIO
-from httpx import AsyncClient
-from gpytranslate import SyncTranslator
-
-from fastapi.templating import Jinja2Templates
-from fastapi.staticfiles import StaticFiles
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from fastapi.responses import StreamingResponse, JSONResponse, FileResponse
-from fastapi.openapi.utils import get_openapi
-from fastapi import Request, Header, Depends, HTTPException, status
-from fastapi import FastAPI, UploadFile, File, Response
-from fastapi import Body, Query
-
-from dotenv import load_dotenv
+import json
+import logging
+import os
+import random
+import re
+from base64 import b64decode
+from base64 import b64decode as kc
 from datetime import datetime as dt
+from io import BytesIO
+from typing import *
+from typing import Union
 
-from bs4 import BeautifulSoup
-from base64 import b64decode as kc
-from base64 import b64decode
+import g4f
+import requests
 from bardapi import Bard
-
-from RyuzakiLib.system import OpenReadSystem
-from RyuzakiLib.spamwatch.clients import SibylBan
-from RyuzakiLib.mental import BadWordsList
-from RyuzakiLib.hackertools.openai_api import OpenAiToken
-from RyuzakiLib.hackertools.gemini import GeminiLatest
+from bs4 import BeautifulSoup
+from dotenv import load_dotenv
+from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from gpytranslate import SyncTranslator
+from httpx import AsyncClient
+from pymongo import MongoClient
 from RyuzakiLib.hackertools.chatgpt import RendyDevChat
+from RyuzakiLib.hackertools.gemini import GeminiLatest
+from RyuzakiLib.mental import BadWordsList
+from serpapi import GoogleSearch
 
 from models import *
 
@@ -103,7 +75,7 @@ HUGGING_TOKEN = os.environ["HUGGING_TOKEN"]
 ASSISTANT_GOOGLE_API_KEYS = os.environ["ASSISTANT_GOOGLE_API_KEYS"]
 COOKIE_BARD_TOKEN = os.environ["COOKIE_BARD_TOKEN"]
 
-#unlocks
+# unlocks
 ORACLE_TOKEN = os.environ["ORACLE_TOKEN"]
 TruAI = os.environ["TruAI"]
 
@@ -125,7 +97,7 @@ app = FastAPI(
         "name": "🌀ʊʄ⊕ք🌀",
         "url": "https://t.me/UFoPInfo",
     },
-    docs_url="/"
+    docs_url="/",
 )
 
 timeout = 100
@@ -145,6 +117,7 @@ Please modify your search terms and/or try again later thank you for your unders
 ~ 🌀ʊʄ⊕ք🌀 Team
 """
 
+
 def get_all_api_keys():
     user = collection.find({})
     api_keys = []
@@ -154,15 +127,18 @@ def get_all_api_keys():
             api_keys.append(api_key)
     return api_keys
 
+
 def validate_api_key(api_key: str = Header(...)):
     USERS_API_KEYS = get_all_api_keys()
     if api_key not in USERS_API_KEYS:
         raise HTTPException(status_code=401, detail="Invalid API key")
 
+
 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 = [
     "Spammer",
     "wanted",
@@ -170,18 +146,22 @@ RAMDOM_STATUS = [
     "rogue_agent",
     "pornbot prolly",
     "fugitive",
-    "simp"
+    "simp",
 ]
 
+
 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
+        "sibyl_userid": None,
     }
-    return collection.update_one({"user_id": user_id}, {"$unset": update_doc}, upsert=True)
+    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 = {
@@ -189,13 +169,19 @@ def new_sibyl_system_banned(user_id, name, reason, date_joined):
         "reason_sibyl": reason,
         "is_banned_sibly": True,
         "date_joined_sib": date_joined,
-        "sibyl_userid": user_id
+        "sibyl_userid": user_id,
     }
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    return collection.update_one(
+        {"user_id": user_id}, {"$set": update_doc}, upsert=True
+    )
+
 
 def cybersecuritydb(user_id, mongo_url):
     update_doc = {"mongodb": mongo_url}
-    return collection.update_one({"user_id": user_id}, {"$set": update_doc}, upsert=True)
+    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})
@@ -209,6 +195,7 @@ def get_sibyl_system_banned(user_id):
     else:
         return None, None, False, None, None
 
+
 def get_all_banned():
     banned_users = []
 
@@ -220,11 +207,14 @@ def get_all_banned():
         banned_users.append({"user_id": user_id, "reason": reason})
     return banned_users
 
+
 @app.get("/UFoP/blacklist-words")
 def blacklist_words():
     try:
         BLACKLIST_WORDS = BadWordsList()
-        results_all = BLACKLIST_WORDS.banned_by_google(file_txt="banned_by_google.txt", storage=True)
+        results_all = BLACKLIST_WORDS.banned_by_google(
+            file_txt="banned_by_google.txt", storage=True
+        )
         return {"status": "true", "results": results_all}
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
@@ -233,17 +223,16 @@ def blacklist_words():
 @app.get("/UFoP/getbanlist")
 def sibyl_get_all_banlist():
     banned_users = get_all_banned()
-    return {
-        "status": "True",
-        "sukuna": {
-            "results": banned_users
-        }
-    }
+    return {"status": "True", "sukuna": {"results": banned_users}}
+
 
-@app.delete("/UFoP/bandel", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+@app.delete(
+    "/UFoP/bandel",
+    response_model=SuccessResponse,
+    responses={422: {"model": ErrorStatus}},
+)
 def sibyl_system_delete(
-    item: SibylSystemDel,
-    api_key: None = Depends(validate_api_key_only_devs)
+    item: SibylSystemDel, api_key: None = Depends(validate_api_key_only_devs)
 ):
     try:
         _, _, _, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
@@ -252,20 +241,25 @@ def sibyl_system_delete(
             remove_sibyl_system_banned(item.user_id)
             return SuccessResponse(
                 status="True",
-                randydev={"message": f"Successfully removed {item.user_id} from the Sibyl ban list"}
+                randydev={
+                    "message": f"Successfully removed {item.user_id} from the Sibyl ban list"
+                },
             )
         else:
             return SuccessResponse(
-                status="False",
-                randydev={"message": "Not Found UserID"}
+                status="False", randydev={"message": "Not Found UserID"}
             )
     except Exception as e:
         return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-@app.post("/UFoP/banner", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+
+@app.post(
+    "/UFoP/banner",
+    response_model=SuccessResponse,
+    responses={422: {"model": ErrorStatus}},
+)
 def sibyl_system_ban(
-    item: SibylSystemBan,
-    api_key: None = Depends(validate_api_key_only_devs)
+    item: SibylSystemBan, api_key: None = Depends(validate_api_key_only_devs)
 ):
     if item.user_id == DEVELOPER_ID:
         return {"status": "false", "message": "Only Developer"}
@@ -277,8 +271,7 @@ def sibyl_system_ban(
 
         if sibyl_user_id is not None and is_banned:
             return SuccessResponse(
-                status="False",
-                randydev={"message": "User is already banned"}
+                status="False", randydev={"message": "User is already banned"}
             )
 
         new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
@@ -289,16 +282,17 @@ def sibyl_system_ban(
                 "sibyl_name": sibyl_ban,
                 "reason": item.reason,
                 "date_joined": date_joined,
-                "message": f"Successfully banned {item.user_id} from the Sibyl ban list."
-            }
+                "message": f"Successfully banned {item.user_id} from the Sibyl ban list.",
+            },
         )
     except Exception as e:
         return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
+
 @app.get("/UFoP/bans")
 def sibyl_system(
     user_id: int = Query(..., description="User ID in query parameter"),
-    api_key: None = Depends(validate_api_key)
+    api_key: None = Depends(validate_api_key),
 ):
     result = get_sibyl_system_banned(user_id)
     if result is not None:
@@ -310,14 +304,19 @@ def sibyl_system(
                 "reason": reason,
                 "is_banned": is_banned,
                 "date_joined": date_joined,
-                "sibyl_user_id": sibyl_user_id
-            }
+                "sibyl_user_id": sibyl_user_id,
+            },
         }
     else:
         return {"status": "false", "message": "Not Found User"}
 
-@app.post("/UFoP/gemini-the-oracle", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
-async def gemini_oracle(item: GeminiOracle): 
+
+@app.post(
+    "/UFoP/gemini-the-oracle",
+    response_model=SuccessResponse,
+    responses={422: {"model": ErrorStatus}},
+)
+async def gemini_oracle(item: GeminiOracle):
     if item.is_multi_chat:
         selected_api_key = ASSISTANT_GOOGLE_API_KEYS or item.gemini_api_key
         oracle_base = ORACLE_TOKEN or item.oracle_base
@@ -327,20 +326,21 @@ async def gemini_oracle(item: GeminiOracle):
                 mongo_url=item.mongo_url,
                 version=item.version,
                 user_id=item.user_id,
-                oracle_base=oracle_base
+                oracle_base=oracle_base,
             )
             cybersecuritydb(item.user_id, item.mongo_url)
             if item.oracle_base == "Delete":
                 clearedhistory = await geni._clear_oracle_history_in_db()
-                return SuccessResponse(status="True", randydev={"message": f"Oracle Status: {clearedhistory}"})
+                return SuccessResponse(
+                    status="True",
+                    randydev={"message": f"Oracle Status: {clearedhistory}"},
+                )
             else:
-                answer, oracle_chat = await geni._GeminiLatest__get_response_oracle(item.query)
+                answer, oracle_chat = await geni._GeminiLatest__get_response_oracle(
+                    item.query
+                )
             return SuccessResponse(
-                status="True",
-                randydev={
-                    "message": answer,
-                    "chat_history": oracle_chat
-                }
+                status="True", randydev={"message": answer, "chat_history": oracle_chat}
             )
         except Exception as excep:
             return SuccessResponse(status="False", randydev={"message": internal_error})
@@ -357,46 +357,44 @@ async def gemini_oracle(item: GeminiOracle):
                 "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/"
+                "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 SuccessResponse(status="False", randydev={"message": contact_support})
+        except BaseException:
+            return SuccessResponse(
+                status="False", randydev={"message": contact_support}
+            )
 
-@app.post("/UFoP/G-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
+
+@app.post(
+    "/UFoP/G-AI",
+    response_model=SuccessResponse,
+    responses={422: {"model": ErrorStatus}},
+)
+def v1beta3_google_ai(item: ChatgptCustom, api_key: None = Depends(validate_api_key)):
     api_url = f"{SOURCE_ASSISTANT_GOOGLE_AI}/models/text-bison-001:generateText?key={ASSISTANT_GOOGLE_API_KEYS}"
     try:
         headers = {"Content-Type": "application/json"}
-        data = {
-            "prompt": {
-                "text": item.query
-            }
-        }
+        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 SuccessResponse(status="True", randydev={"message": message})
+    except BaseException:
         return SuccessResponse(status="False", randydev={"message": internal_error})
 
-@app.post("/UFoP/gemini-ai-pro", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
+
+@app.post(
+    "/UFoP/gemini-ai-pro",
+    response_model=SuccessResponse,
+    responses={422: {"model": ErrorStatus}},
+)
 def gemini_pro(item: GeminiPro):
     owner_base = TruAI
     if item.is_multi_chat:
@@ -406,19 +404,17 @@ def gemini_pro(item: GeminiPro):
                 api_key=selected_api_key,
                 mongo_url=item.mongo_url,
                 version=item.version,
-                user_id=item.user_id
+                user_id=item.user_id,
             )
             cybersecuritydb(item.user_id, item.mongo_url)
             answer, gemini_chat = geni._GeminiLatest__get_response_gemini(item.query)
             return SuccessResponse(
-                status="True",
-                randydev={
-                    "message": answer,
-                    "chat_history": gemini_chat
-                }
+                status="True", randydev={"message": answer, "chat_history": gemini_chat}
             )
         except Exception:
-            return SuccessResponse(status="False", randydev={"message": contact_support})
+            return SuccessResponse(
+                status="False", randydev={"message": contact_support}
+            )
     else:
         if item.is_login:
             token = item.bard_api_key
@@ -432,21 +428,21 @@ def gemini_pro(item: GeminiPro):
                 "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/"
+                "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 SuccessResponse(status="False", randydev={"message": contact_support})
+        except BaseException:
+            return SuccessResponse(
+                status="False", randydev={"message": contact_support}
+            )
+
 
 @app.post("/UFoP/dalle3xl")
-def dalle_3xl(
-    item: Dalle3XL,
-    api_key: None = Depends(validate_api_key)
-):
+def dalle_3xl(item: Dalle3XL, api_key: None = Depends(validate_api_key)):
     API_URL = SOURCE_DALLE3XL_URL
     try:
         payload = {"inputs": item.query}
@@ -454,21 +450,17 @@ def dalle_3xl(
             "Authorization": f"Bearer {HUGGING_TOKEN}",
             "Content-Type": "application/json",
         }
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=timeout)
+        response = requests.post(
+            API_URL, headers=headers, json=payload, timeout=timeout
+        )
         response.raise_for_status()
     except requests.exceptions.RequestException:
-        raise HTTPException(
-            status_code=500,
-            detail=internal_error
-        )
+        raise HTTPException(status_code=500, detail=internal_error)
 
     try:
         encoded_string = base64.b64encode(response.content).decode("utf-8")
     except Exception:
-        raise HTTPException(
-            status_code=500,
-            detail=contact_support
-        )
+        raise HTTPException(status_code=500, detail=contact_support)
 
     if encoded_string:
         return SuccessResponse(status="True", randydev={"data": encoded_string})
@@ -477,7 +469,7 @@ def dalle_3xl(
 
 
 @app.get("/ryuzaki/unsplash")
-async def get_image_unsplash(query: str, size: str="500x500"):
+async def get_image_unsplash(query: str, size: str = "500x500"):
     url = SOURCE_UNSPLASH_URL
     image_url = f"{url}/?{query}/{size}"
 
@@ -489,20 +481,21 @@ async def get_image_unsplash(query: str, size: str="500x500"):
 
     return StreamingResponse(BytesIO(response.content), media_type="image/jpeg")
 
+
 @app.get("/ryuzaki/reverse")
 def google_reverse(
-    engine: str="google_reverse_image",
-    image_url: str=None,
-    language: str="en",
-    google_lang: str="us",
-    api_key: None = Depends(validate_api_key)
+    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": engine,
         "image_url": image_url,
         "hl": language,
-        "gl": google_lang
+        "gl": google_lang,
     }
     try:
         search = GoogleSearch(params)
@@ -517,24 +510,25 @@ def google_reverse(
                 "link": link,
                 "total_time_taken": total_time_taken,
                 "create_at": create_at,
-                "processed_at": processed_at
-            }
+                "processed_at": processed_at,
+            },
         }
     except Exception as e:
         return {"status": "false", "message": f"Error {e}"}
 
+
 @app.get("/ryuzaki/ocr")
 def ocr_space_url(
     url: str = Query(..., description="URL in query parameter"),
-    overlay: bool=False,
+    overlay: bool = False,
     language: str = Query("eng", description="Language in query parameter"),
-    api_key: None = Depends(validate_api_key)
+    api_key: None = Depends(validate_api_key),
 ):
     payload = {
         "url": url,
         "isOverlayRequired": overlay,
         "apikey": OCR_API_KEY,
-        "language": language
+        "language": language,
     }
     try:
         response = requests.post(SOURCE_OCR_URL, data=payload)
@@ -544,61 +538,50 @@ def ocr_space_url(
         return f"Error: {str(e)}"
     try:
         parsed_response = json.loads(test_url)
-        if "ParsedResults" in parsed_response and len(parsed_response["ParsedResults"]) > 0:
+        if (
+            "ParsedResults" in parsed_response
+            and len(parsed_response["ParsedResults"]) > 0
+        ):
             return {
                 "status": "true",
-                "sukuna":{
-                    "text": parsed_response["ParsedResults"][0]["ParsedText"]
-                }
+                "sukuna": {"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,
-    api_key: None = Depends(validate_api_key)
-):
+def chatgpt4_support(query: str = None, api_key: None = Depends(validate_api_key)):
     try:
         response = g4f.ChatCompletion.create(
             model=g4f.models.gpt_4,
             messages=[{"role": "user", "content": query}],
         )
-        return {
-            "status": "true",
-            "sukuna":{
-                "message": response
-            }
-        }
-    except:
+        return {"status": "true", "sukuna": {"message": response}}
+    except BaseException:
         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
-):
+def chatgpt_model(query: str = None, model_id: int = 1, is_models: bool = True):
     try:
-        response = RendyDevChat(query).get_response_model(model_id=model_id, is_models=is_models)
-        return {
-            "status": "true",
-            "sukuna":{
-                "message": response
-            }
-        }
-    except:
+        response = RendyDevChat(query).get_response_model(
+            model_id=model_id, is_models=is_models
+        )
+        return {"status": "true", "sukuna": {"message": response}}
+    except BaseException:
         return {"status": "false", "message": "Error response."}
 
+
 async def get_data(username):
     base_msg = ""
     async with AsyncClient() as gpx:
         req = (await gpx.get(f"https://api.github.com/users/{username}")).json()
         try:
             avatar = req["avatar_url"]
-            twitter = req['twitter_username']
+            twitter = req["twitter_username"]
             base_msg += "**❆ Gitub Information ❆** \n\n"
             base_msg += f"**Profile Url:** {req['html_url']} \n"
             base_msg += f"**Name:** `{req['name']}` \n"
@@ -620,52 +603,49 @@ 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):
+async def github(username: str = None):
     try:
         details = await get_data(username)
         return {
             "status": "true",
-            "sukuna":{
-                "avatar": details[1],
-                "results": details[0]
-            }
+            "sukuna": {"avatar": details[1], "results": details[0]},
         }
-    except:
+    except BaseException:
         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"
+    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/{quality}/{type_mine}/{pixels}/{cast}/?{url}"
-        return {
-            "status": "true",
-            "sukuna":{
-                "image_url": required_url
-            }
-        }
-    except:
+        required_url = (
+            f"https://mini.s-shot.ru/{quality}/{type_mine}/{pixels}/{cast}/?{url}"
+        )
+        return {"status": "true", "sukuna": {"image_url": required_url}}
+    except BaseException:
         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
+    query: str = None,
+    user_id: int = None,
+    bot_name: str = None,
+    bot_username: str = None,
 ):
     api_url = b64decode("aHR0cHM6Ly9hcGkuc2Fmb25lLmRldi9jaGF0Ym90").decode("utf-8")
     params = {
         "query": query,
         "user_id": user_id,
         "bot_name": bot_name,
-        "bot_master": bot_username
+        "bot_master": bot_username,
     }
     x = requests.get(f"{api_url}", params=params)
     if x.status_code != 200:
@@ -673,27 +653,22 @@ def chatbot(
     try:
         y = x.json()
         response = y["response"]
-        return {
-            "status": "true",
-            "sukuna":{
-                "message": response
-            }
-        }
-    except:
+        return {"status": "true", "sukuna": {"message": response}}
+    except BaseException:
         return {"status": "false", "message": "Error response."}
 
+
 @app.get("/ryuzaki/waifu")
-def waifu_pics(
-    types: str="sfw",
-    category: str="neko"
-):
+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)
 
     if response.status_code != 200:
-        return "Sorry, there was an error processing your request. Please try again later"
+        return (
+            "Sorry, there was an error processing your request. Please try again later"
+        )
     data_waifu = response.json()
     try:
         waifu_image_url = data_waifu["url"]
@@ -701,25 +676,21 @@ def waifu_pics(
         return f"Error request {e}"
     if waifu_image_url:
         try:
-            return {
-                "status": "true",
-                "sukuna":{
-                    "image_url": waifu_image_url
-                }
-            }
-        except:
+            return {"status": "true", "sukuna": {"image_url": waifu_image_url}}
+        except BaseException:
             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
+    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")
@@ -732,52 +703,33 @@ def make_rayso(
     if ryuzaki_dark:
         x = requests.post(
             f"{api_url}",
-            json={
-                "code": code,
-                "title": title,
-                "theme": theme,
-                "darkMode": True
-            }
+            json={"code": code, "title": title, "theme": theme, "darkMode": True},
         )
         if x.status_code != 200:
             return "Error api Gay"
         data = x.json()
         try:
             image_data = base64.b64decode(data["image"])
-            return {
-                "status": "true",
-                "data":{
-                    "image": image_data
-                }
-            }
-        except:
+            return {"status": "true", "data": {"image": image_data}}
+        except BaseException:
             return {"status": "false", "message": "Error response"}
     else:
         x = requests.post(
             f"{api_url}",
-            json={
-                "code": code,
-                "title": title,
-                "theme": theme,
-                "darkMode": False
-            }
+            json={"code": code, "title": title, "theme": theme, "darkMode": False},
         )
         if x.status_code != 200:
             return "Error api Gay"
         data = x.json()
         try:
             image_data = base64.b64decode(data["image"])
-            return {
-                "status": "true",
-                "data":{
-                    "image": image_data
-                }
-            }
-        except:
+            return {"status": "true", "data": {"image": image_data}}
+        except BaseException:
             return {"status": "false", "message": "Error response"}
 
+
 @app.get("/ryuzaki/ipcheck")
-def whois_ip_address(ip_address: str=None):
+def whois_ip_address(ip_address: str = None):
     apikey = kc("M0QwN0UyRUFBRjU1OTQwQUY0NDczNEMzRjJBQzdDMUE=").decode("utf-8")
     location_link = "https"
     location_api = "api.ip2location.io"
@@ -788,7 +740,9 @@ def whois_ip_address(ip_address: str=None):
     )
     response = requests.get(location_param)
     if response.status_code != 200:
-        return "Sorry, there was an error processing your request. Please try again later"
+        return (
+            "Sorry, there was an error processing your request. Please try again later"
+        )
     data_location = response.json()
     try:
         location_ip = data_location["ip"]
@@ -818,19 +772,24 @@ def whois_ip_address(ip_address: str=None):
             "city_name": location_city,
             "zip_code": location_zip,
             "time_zone": location_zone,
-            "as": location_card
+            "as": location_card,
         }
     else:
         return {"status": "false", "message": "Invalid ip address"}
 
+
 @app.get("/ryuzaki/tiktok_douyin")
-def tiktok_douyin(tiktok_url: str=None):
+def tiktok_douyin(tiktok_url: str = None):
     response = requests.get(f"{SOURCE_TIKTOK_WTF_URL}={tiktok_url}")
     if response.status_code != 200:
         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]
+        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]
         description = response.json()["aweme_list"][0]["desc"]
         author = response.json()["aweme_list"][0]["author"]["nickname"]
         request = response.json()["aweme_list"][0]["author"]["signature"]
@@ -841,14 +800,15 @@ def tiktok_douyin(tiktok_url: str=None):
                 "music_url": download_audio,
                 "description": description,
                 "author": author,
-                "request": request
-            }
+                "request": request,
+            },
         }
-    except:
+    except BaseException:
         return {"status": "false", "message": "Error request"}
 
+
 @app.get("/ryuzaki/tiktok")
-def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None):
+def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool = None):
     api_devs = SOURCE_TIKTOK_TECH_URL
     parameter = f"tiktok?url={tiktok_url}"
     api_url = f"{api_devs}/{parameter}"
@@ -862,209 +822,208 @@ def tiktok_downloader(tiktok_url: Union[str, None] = None, only_video: bool=None
         if only_video:
             video_url = results.get("result", {}).get("withoutWaterMarkVideo", "")
             if video_url:
-                return {
-                    "download_url": video_url,
-                    "caption": caption
-                }
+                return {"download_url": video_url, "caption": caption}
         else:
             music_mp3 = results.get("result", {}).get("music", "")
             if music_mp3:
-                return {
-                    "music_url": music_mp3,
-                    "caption": caption
-                }
+                return {"music_url": music_mp3, "caption": caption}
         return "Error: TikTok data not found or unsupported format"
-    except:
+    except BaseException:
         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
+    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},
+                    },
+                }
             },
-            "DateAndTime": {
-              "time": time,
-              "date": date
-            }
-          }
         }
-      }
-    }
 
-  except:
-    return "{'status': 'false', 'message': 'Invalid Link'}"
+    except BaseException:
+        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.'
+    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."
+                        ),
+                    },
+                }
             },
-            "DateAndTime":
-            last_modified if last_modified else
-            'No last modified date provided by the server.',
-          }
         }
-      }
-    }
 
-  except:
-    return "{'status': 'false', 'message': 'Invalid Link'}"
+    except BaseException:
+        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'}"
+    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 BaseException:
+        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'}"
+    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 BaseException:
+        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'}"
+    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 BaseException:
+        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'}"
+    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 BaseException:
+        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'}"
+    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 BaseException:
+        return "{'status': 'false', 'message': 'Invalid Link'}"
+
 
 def custom_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
     error_detail = [{"error": str(exc.detail)}]
@@ -1076,5 +1035,6 @@ def custom_exception_handler(request: Request, exc: HTTPException) -> JSONRespon
         headers=exc.headers,
     )
 
+
 # Add the custom exception handler to your FastAPI app
-app.add_exception_handler(HTTPException, custom_exception_handler)
+app.add_exception_handler(HTTPException, custom_exception_handler)

models.py

@@ -1,23 +1,30 @@
 import os
-from typing import Optional, List, Dict, Any
+from typing import Any, Dict, List, Optional
+
 from pydantic import BaseModel
+
 ORACLE_TOKEN = os.environ["ORACLE_TOKEN"]
 
+
 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
@@ -25,22 +32,28 @@ class ProfileClone(BaseModel):
     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
@@ -48,29 +61,35 @@ class SibylSystemResponse(BaseModel):
     date_joined: str
     sibyl_user_id: int
 
+
 class GoogleReverse(BaseModel):
-    engine: str="google_reverse_image"
+    engine: str = "google_reverse_image"
     image_url: str
-    language: str="en"
-    google_lang: str="us"
+    language: str = "en"
+    google_lang: str = "us"
+
 
 class GetImageUnsplash(BaseModel):
     query: str
-    size: str="500x500"
+    size: str = "500x500"
+
 
 class OrcSpaceUrl(BaseModel):
     url: str
-    overlay: bool=False
-    language: str="eng"
+    overlay: bool = False
+    language: str = "eng"
+
 
 class ChatgptModel(BaseModel):
     query: str
     model_id: Optional[int] = None
-    is_models: bool=False
+    is_models: bool = False
+
 
 class ChatgptCustom(BaseModel):
     query: str
 
+
 class GeminiPro(BaseModel):
     query: str
     bard_api_key: Optional[str] = None
@@ -81,6 +100,7 @@ class GeminiPro(BaseModel):
     is_login: Optional[bool] = False
     is_multi_chat: Optional[bool] = False
 
+
 class GeminiOracle(BaseModel):
     query: str
     bard_api_key: Optional[str] = None
@@ -92,73 +112,89 @@ class GeminiOracle(BaseModel):
     is_login: Optional[bool] = False
     is_multi_chat: Optional[bool] = False
 
+
 class WaifuPics(BaseModel):
-    types: str="sfw"
-    category: str="neko"
+    types: str = "sfw"
+    category: str = "neko"
     media_type: Optional[str] = None
-    is_bytes: bool=False
+    is_bytes: bool = False
+
 
 class MakeRayso(BaseModel):
     code: str
-    title: str="Ryuzaki Dev"
+    title: str = "Ryuzaki Dev"
     theme: str
-    setlang: str="en"
+    setlang: str = "en"
     auto_translate: Optional[bool] = None
-    ryuzaki_dark: bool=True
+    ryuzaki_dark: bool = True
+
 
 class Webshot(BaseModel):
     url: str
-    quality: str="1920x1080"
-    type_mine: str="JPEG"
-    pixels: str="1024"
-    cast: str="Z100"
+    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 NewMonitor(BaseModel):
-    type: int=1
+    type: int = 1
     url: str
     friendly_name: str
 
+
 class TiktokBeta(BaseModel):
     tiktok_url: str
     only_video: Optional[bool] = None
 
+
 class TiktokDownloader(BaseModel):
     tiktok_url: str
 
+
 class GetMonitorLogs(BaseModel):
     logs: int
 
+
 class DownloadLink(BaseModel):
     link: str
 
+
 class OpenDalle(BaseModel):
     query: str
 
+
 class Dalle3XL(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] = ""
@@ -166,8 +202,10 @@ class Chatgpt3Texts(BaseModel):
     is_stream: Optional[bool] = False
     is_openai_original: Optional[bool] = False
 
+
 class TextCustom(BaseModel):
     query: str
 
+
 class Picsart(BaseModel):
-    image_path: str
+    image_path: str

templates/config.py

@@ -1,7 +1,7 @@
-TITLE="title template"
-DESCRIPTION="description template"
-VERSION="0.0.1"
-TERMS_OF_SERVICE="terms template"
-DOCS_URL="/"
-API_KEYS="" # get api key from @randydev_bot use /token_api_key
-TELEGRAM_ID=0
+TITLE = "title template"
+DESCRIPTION = "description template"
+VERSION = "0.0.1"
+TERMS_OF_SERVICE = "terms template"
+DOCS_URL = "/"
+API_KEYS = ""  # get api key from @randydev_bot use /token_api_key
+TELEGRAM_ID = 0

templates/main.py

@@ -17,49 +17,10 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-import requests
-import json
-import base64
-import re
 import uvicorn
-import os
-import shutil
-import random
-import g4f
-import tempfile
-import io
-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_extensions import Annotated
-from typing import Annotated, Union
-
-from pydantic import BaseModel
-from base64 import b64decode as kc
-from base64 import b64decode
-from random import choice
-from gpytranslate import SyncTranslator
-from httpx import AsyncClient
-from telegraph import Telegraph, upload_file
-from pathlib import Path
-from serpapi import GoogleSearch
-
-from fastapi import FastAPI, UploadFile, File
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from fastapi import Depends, FastAPI, HTTPException, status
-from fastapi.responses import StreamingResponse
-from fastapi import HTTPException
-from fastapi import FastAPI, Request, Header
-from fastapi import Body, Query
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from fastapi.responses import FileResponse
+from fastapi import FastAPI, Query
 
 from templates.config import *
-from RyuzakiLib.spamwatch.clients import SibylBan
 
 logging.basicConfig(level=logging.ERROR)
 
@@ -68,27 +29,32 @@ app = FastAPI(
     description=DESCRIPTION,
     version=VERSION,
     terms_of_service=TERMS_OF_SERVICE,
-    docs_url=DOCS_URL
+    docs_url=DOCS_URL,
 )
 
+
 @app.get("/test")
 def hello_world():
     return {"message": "hello world"}
 
+
 @app.get("/ryuzaki/blacklist-words")
 def blacklist_words():
     try:
         BLACKLIST_WORDS = BadWordsList()
-        results_all = BLACKLIST_WORDS.banned_by_google(file_txt="banned_by_google.txt", storage=True)
+        results_all = BLACKLIST_WORDS.banned_by_google(
+            file_txt="banned_by_google.txt", storage=True
+        )
         return {"status": "true", "results": results_all}
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
+
 @app.post("/ryuzaki/sibylban")
 def sibyl_system_ban(
     user_id: int = Query(..., description="User ID in query parameter"),
     reason: str = Query(..., description="Reason in query parameter"),
-    api_key: str = Query(..., description="Api key in query parameter")
+    api_key: str = Query(..., description="Api key in query parameter"),
 ):
     if user_id != TELEGRAM_ID:
         return {"status": "false", "message": "Only Developer"}
@@ -101,15 +67,11 @@ def sibyl_system_ban(
             return {"status": "false", "message": "User is already banned"}
 
         response_str = clients.add_ban(user_id=user_id, reason=reason, is_banned=True)
-        return {
-            "status": "true",
-            "results": {
-                "message": response_str
-            }
-        }
+        return {"status": "true", "results": {"message": response_str}}
     except Exception as e:
         logging.error(f"Error in sibyl_system_ban: {e}")
         return {"status": "false", "message": "Internal server error"}
 
+
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0")