Upload main.py

main.py

@@ -35,6 +35,7 @@ from bs4 import BeautifulSoup
 from typing import Union
 from typing_extensions import Annotated
 from typing import Annotated, Union
+from typing import Optional
 
 from pydantic import BaseModel
 from base64 import b64decode as kc
@@ -201,45 +202,63 @@ def get_profile_clone(user_id):
     else:
         return None
 
-@app.post("/ryuzaki/profile-clone")
+class CustomErrorResponseModel(BaseModel):
+    detail: List[Dict[str, Any]]
+
+class SuccessResponse(BaseModel):
+    status: str
+    message: str
+
+class ErrorResponse(BaseModel):
+    status: str
+    detail: 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
+
+@app.post("/ryuzaki/profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def profile_clone(
-    user_id: int,
-    first_name=None,
-    last_name=None,
-    profile_id=None,
-    bio=None,
+    item: ProfileClone,
     api_key: None = Depends(validate_api_key)
 ):
-    if user_id == 1191668125: # only devs
+    if item.user_id == 1191668125:
         return {"status": "false", "message": "Only Developer"}
+
     try:
         new_profile_clone(
-            user_id=user_id,
-            first_name=first_name,
-            last_name=last_name,
-            profile_id=profile_id,
-            bio=bio
+            user_id=item.user_id,
+            first_name=item.first_name,
+            last_name=item.last_name,
+            profile_id=item.profile_id,
+            bio=item.bio
         )
         return {
             "status": "true",
             "randydev": {
-                "user_id": user_id,
-                "first_name": first_name,
-                "last_name": last_name,
-                "profile_id": profile_id,
-                "bio": bio
+                "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 {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.get("/ryuzaki/get-profile-clone")
+class GetProfileClone(BaseModel):
+    user_id: int
+
+@app.get("/ryuzaki/get-profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def get_profile_(
-    user_id: int,
+    item: GetProfileClone,
     api_key: None = Depends(validate_api_key)
 ):
     try:
-        first_name, last_name, profile_id, bio = get_profile_clone(user_id)
+        first_name, last_name, profile_id, bio = get_profile_clone(item.user_id)
         if last_name is None:
             last_name_str = ""
         else:
@@ -252,7 +271,7 @@ def get_profile_(
             return {
                 "status": "true",
                 "randydev": {
-                    "user_id": user_id,
+                    "user_id": item.user_id,
                     "first_name": first_name,
                     "last_name": last_name_str,
                     "profile_id": profile_id,
@@ -283,61 +302,70 @@ def blacklist_words():
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.delete("/ryuzaki/sibyldel")
+class SibylSystemDel(BaseModel):
+    user_id: int
+
+@app.delete("/ryuzaki/sibyldel", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 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 = get_sibyl_system_banned(user_id)
+        _, _, _, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
 
         if sibyl_user_id:
-            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 {"status": "true", "message": f"Successfully removed {item.user_id} from the Sibyl ban list."}
         else:
             return {"status": "false", "message": "Not found user"}
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-@app.post("/ryuzaki/sibylban")
+class SibylSystemBan(BaseModel):
+    user_id: int
+    reason: str
+
+@app.post("/ryuzaki/sibylban", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def sibyl_system_ban(
-    user_id: int = Query(..., description="User ID in query parameter"),
-    reason: str = Query(..., description="Reason in query parameter"),
+    item: SibylSystemBan,
     api_key: None = Depends(validate_api_key)
 ):
-    if user_id == 1191668125: # only devs
+    if item.user_id == 1191668125:
         return {"status": "false", "message": "Only Developer"}
 
     try:
         date_joined = str(dt.now())
         sibyl_ban = random.choice(RAMDOM_STATUS)
-        _, _, is_banned, _, sibyl_user_id = get_sibyl_system_banned(user_id)
+        _, _, is_banned, _, sibyl_user_id = get_sibyl_system_banned(item.user_id)
 
         if sibyl_user_id and is_banned:
             return {"status": "false", "message": "User is already banned"}
 
-        new_sibyl_system_banned(user_id, sibyl_ban, reason, date_joined)
+        new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
 
         return {
             "status": "true",
             "randydev": {
-                "user_id": user_id,
+                "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"}
 
-@app.get("/ryuzaki/sibyl")
+class SibylSystem(BaseModel):
+    user_id: int
+
+@app.get("/ryuzaki/sibyl", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def sibyl_system(
-    user_id: int = Query(..., description="User ID in query parameter"),
+    item: SibylSystem,
     api_key: None = Depends(validate_api_key)
 ):
-    sibyl_name, reason, is_banned, date_joined, sibyl_user_id = get_sibyl_system_banned(user_id)
+    sibyl_name, reason, is_banned, date_joined, sibyl_user_id = get_sibyl_system_banned(item.user_id)
     if sibyl_name and reason and is_banned and date_joined and sibyl_user_id:
         return {
             "status": "true",
@@ -352,13 +380,16 @@ def sibyl_system(
     else:
         return {"status": "false", "message": "Not Found User"}
 
-@app.get("/ryuzaki/ai")
+class RyuzakiAi(BaseModel):
+    text: str
+
+@app.get("/ryuzaki/ai", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def ryuzaki_ai(
-    text: str = Query(..., description="text in query parameter"),
+    item: RyuzakiAi,
     api_key: None = Depends(validate_api_key)
 ):
     try:
-        response_data = code.ryuzaki_ai_text(text)
+        response_data = code.ryuzaki_ai_text(item.text)
 
         if isinstance(response_data, list) and len(response_data) > 0:
             first_result = response_data[0]
@@ -376,19 +407,29 @@ def ryuzaki_ai(
     except Exception:
         return {"status": "false", "message": "Internal server error"}
 
-@app.get("/ryuzaki/unsplash")
-async def get_image_unsplash(query: str, size: str = "500x500"):
+class GetImageUnsplash(BaseModel):
+    query: str
+    size: str="500x500"
+
+@app.get("/ryuzaki/unsplash", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+async def get_image_unsplash(item: GetImageUnsplash):
     url = SOURCE_UNSPLASH_URL
-    image_url = f"{url}/?{query}/{size}"
+    image_url = f"{url}/?{item.query}/{item.size}"
     try:
         response = requests.get(image_url)
         response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+    except requests.exceptions.RequestException:
+        raise HTTPException(
+            status_code=500,
+            detail=CustomErrorResponseModel(detail=[{}])
+        )
     try:
         encoded_string = base64.b64encode(response.content).decode("utf-8")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error encoding image: {str(e)}")
+    except Exception:
+        raise HTTPException(
+            status_code=500,
+            detail=CustomErrorResponseModel(detail=[{}])
+        )
     headers = {"Content-Type": "image/jpeg"}
     return Response(
         content=encoded_string,
@@ -396,33 +437,23 @@ async def get_image_unsplash(query: str, size: str = "500x500"):
         headers=headers
     )
 
-@app.get("/ryuzaki/calligraphy")
-async def get_image_calligraphy(query: str):
-    url = SOURCE_CALLI_GRAPHY_URL
-    image_url = f"{url}?style=1&text={query}"
-
-    try:
-        response = requests.get(image_url)
-        response.raise_for_status()
-    except requests.exceptions.RequestException:
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-    return StreamingResponse(BytesIO(response.content), media_type="image/jpeg")
+class GoogleReverse(BaseModel):
+    engine: str="google_reverse_image"
+    image_url: str
+    language: str="en"
+    google_lang: str="us"
 
-@app.get("/ryuzaki/reverse")
+@app.get("/ryuzaki/reverse", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 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)
@@ -443,18 +474,21 @@ def google_reverse(
     except Exception:
         return {"status": "false", "message": "Internal server error"}
 
-@app.get("/ryuzaki/ocr")
+class OrcSpaceUrl(BaseModel):
+    url: str
+    overlay: bool=False
+    language: str="eng"
+
+@app.get("/ryuzaki/ocr", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 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)
@@ -476,11 +510,16 @@ def ocr_space_url(
     except (json.JSONDecodeError, KeyError):
         return "Error parsing the OCR response."
 
-@app.post("/ryuzaki/chatgpt-model")
-def chatgpt_model(query: str=None, model_id: int=None, is_models: bool=False):
+class ChatgptModel(BaseModel):
+    query: str
+    model_id: Optional[int] = None
+    is_models: bool=False
+
+@app.post("/ryuzaki/chatgpt-model", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+def chatgpt_model(item: ChatgptModel):
     url = "https://lexica.qewertyy.me/models"
-    if is_models:
-        params = {"model_id": model_id, "prompt": query}
+    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}"
@@ -493,7 +532,7 @@ def chatgpt_model(query: str=None, model_id: int=None, is_models: bool=False):
             }
         }
     else:
-        params = {"model_id": 5, "prompt": query}
+        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}"
@@ -506,10 +545,13 @@ def chatgpt_model(query: str=None, model_id: int=None, is_models: bool=False):
             }
         }
 
-@app.get("/ryuzaki/freechatgpt-beta")
-def free_chatgpt4_beta(query: str):
+class ChatgptCustom(BaseModel):
+    query: str
+
+@app.get("/ryuzaki/freechatgpt-beta", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+def free_chatgpt4_beta(item: ChatgptCustom):
     try:
-        response = RendyDevChat(query).get_response_beta(joke=True)
+        response = RendyDevChat(item.query).get_response_beta(joke=True)
         return {
             "status": "true",
             "randydev":{
@@ -519,8 +561,8 @@ def free_chatgpt4_beta(query: str):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.get("/ryuzaki/freechatgpt-bing")
-def free_chatgpt4_bing(query: str):
+@app.get("/ryuzaki/freechatgpt-bing", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+def free_chatgpt4_bing(item: ChatgptCustom):
     try:
         response = RendyDevChat(query).get_response_bing(bing=True)
         return {
@@ -532,8 +574,11 @@ def free_chatgpt4_bing(query: str):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.post("/ryuzaki/google-ai")
-def v1beta3_google_ai(query: str, api_key: None = Depends(validate_api_key)):
+@app.post("/ryuzaki/google-ai", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+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}"
@@ -541,7 +586,7 @@ def v1beta3_google_ai(query: str, api_key: None = Depends(validate_api_key)):
         headers = {"Content-Type": "application/json"}
         data = {
             "prompt": {
-                "text": query
+                "text": item.query
             }
         }
         response = requests.post(api_url, headers=headers, json=data)
@@ -558,15 +603,18 @@ def v1beta3_google_ai(query: str, api_key: None = Depends(validate_api_key)):
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.post("/ryuzaki/gemini-ai-pro")
+class GeminiPro(BaseModel):
+    query: str
+    bard_api_key: Optional[str] = None
+    is_login: bool=False
+
+@app.post("/ryuzaki/gemini-ai-pro", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
 def gemini_pro(
-    query: str,
-    bard_api_key: str=None,
-    is_login: bool=False,
+    item: GeminiPro,
     api_key: None = Depends(validate_api_key)
 ):
-    if is_login:
-        token = bard_api_key
+    if item.is_login:
+        token = item.bard_api_key
     else:
         token = COOKIE_BARD_TOKEN
     owner_base = f"""
@@ -588,7 +636,7 @@ def gemini_pro(
         session.cookies.set("__Secure-1PSID", token)
         bard = Bard(token=token, session=session, timeout=30)
         bard.get_answer(owner_base)["content"]
-        message = bard.get_answer(query)["content"]
+        message = bard.get_answer(item.query)["content"]
         return {
             "status": "true",
             "randydev":{
@@ -600,7 +648,7 @@ def gemini_pro(
 
 @app.post("/ryuzaki/v1beta2-google-ai")
 def v1beta2_google_ai(
-    query: str,
+    item: ChatgptCustom,
     api_key: None = Depends(validate_api_key)
 ):
     url = SOURCE_ASSISTANT_GOOGLE_AI
@@ -610,7 +658,7 @@ def v1beta2_google_ai(
         headers = {"Content-Type": "application/json"}
         data = {
             "prompt": {
-                "messages": [{"content": query}]}
+                "messages": [{"content": item.query}]}
         }
         response = requests.post(api_url, headers=headers, json=data)
         response_str = response.json()
@@ -1209,7 +1257,7 @@ def custom_openapi():
         return app.openapi_schema
     openapi_schema = get_openapi(
         title="RyuzakiLib API",
-        version="1.3.1",
+        version="2.2.1",
         summary="Use It Only For Personal Project Else I Need To Delete The Api",
         description=description,
         routes=app.routes,