Upload main.py

main.py

@@ -214,6 +214,10 @@ 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
@@ -221,7 +225,51 @@ class ProfileClone(BaseModel):
     profile_id: Optional[str] = None
     bio: Optional[str] = None
 
-@app.post("/ryuzaki/profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+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 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
+
+@app.post("/ryuzaki/profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def profile_clone(
     item: ProfileClone,
     api_key: None = Depends(validate_api_key)
@@ -237,23 +285,20 @@ def profile_clone(
             profile_id=item.profile_id,
             bio=item.bio
         )
-        return {
-            "status": "true",
-            "randydev": {
+        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 {"status": "false", "message": f"Internal server error: {str(e)}"}
+        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-class GetProfileClone(BaseModel):
-    user_id: int
-
-@app.get("/ryuzaki/get-profile-clone", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@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)
@@ -269,20 +314,20 @@ def get_profile_(
         else:
             bio_str = bio
         if first_name and profile_id:
-            return {
-                "status": "true",
-                "randydev": {
+            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 {"status": "false", "message": "Not Found User"}
+            return ErrorStatus(status="false", message="Not found user")
     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.get("/ryuzaki/getbanlist")
 def sibyl_get_all_banlist():
@@ -303,10 +348,7 @@ def blacklist_words():
     except Exception as e:
         return {"status": "false", "message": f"Internal server error: {str(e)}"}
 
-class SibylSystemDel(BaseModel):
-    user_id: int
-
-@app.delete("/ryuzaki/sibyldel", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.delete("/ryuzaki/sibyldel", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system_delete(
     item: SibylSystemDel,
     api_key: None = Depends(validate_api_key_only_devs)
@@ -316,17 +358,18 @@ def sibyl_system_delete(
 
         if sibyl_user_id:
             remove_sibyl_system_banned(item.user_id)
-            return {"status": "true", "message": f"Successfully removed {item.user_id} from the Sibyl ban list."}
+            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 ErrorStatus(status="false", message="Not found user")
     except Exception as e:
-        return {"status": "false", "message": f"Internal server error: {str(e)}"}
-
-class SibylSystemBan(BaseModel):
-    user_id: int
-    reason: str
+        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-@app.post("/ryuzaki/sibylban", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.post("/ryuzaki/sibylban", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system_ban(
     item: SibylSystemBan,
     api_key: None = Depends(validate_api_key)
@@ -343,48 +386,40 @@ def sibyl_system_ban(
             return {"status": "false", "message": "User is already banned"}
 
         new_sibyl_system_banned(item.user_id, sibyl_ban, item.reason, date_joined)
-
-        return {
-            "status": "true",
-            "randydev": {
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "user_id": item.user_id,
                 "sibyl_name": sibyl_ban,
                 "reason": item.reason,
                 "date_joined": date_joined,
                 "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"}
-
-class SibylSystem(BaseModel):
-    user_id: int
+        return ErrorStatus(status="false", message=f"Internal server error: {str(e)}")
 
-@app.get("/ryuzaki/sibyl", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.get("/ryuzaki/sibyl", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def sibyl_system(
     item: SibylSystem,
     api_key: None = Depends(validate_api_key)
 ):
     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",
-            "randydev": {
+        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"}
-
-class RyuzakiAi(BaseModel):
-    text: str
+        return ErrorStatus(status="false", message="Not found user")
 
-@app.get("/ryuzaki/ai", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.get("/ryuzaki/ai", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def ryuzaki_ai(
     item: RyuzakiAi,
     api_key: None = Depends(validate_api_key)
@@ -396,23 +431,18 @@ def ryuzaki_ai(
             first_result = response_data[0]
             if "generated_text" in first_result:
                 message = first_result["generated_text"]
-                return {
-                    "status": "true",
-                    "randydev": {
+                return SuccessResponse(
+                    status="True",
+                    randydev={
                         "ryuzaki_text": message
                     }
-                }
-
+                )
         return {"status": "false", "message": "Invalid response format"}
 
     except Exception:
         return {"status": "false", "message": "Internal server error"}
 
-class GetImageUnsplash(BaseModel):
-    query: str
-    size: str="500x500"
-
-@app.get("/ryuzaki/unsplash", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.get("/ryuzaki/unsplash", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 async def get_image_unsplash(item: GetImageUnsplash):
     url = SOURCE_UNSPLASH_URL
     image_url = f"{url}/?{item.query}/{item.size}"
@@ -438,13 +468,7 @@ async def get_image_unsplash(item: GetImageUnsplash):
         headers=headers
     )
 
-class GoogleReverse(BaseModel):
-    engine: str="google_reverse_image"
-    image_url: str
-    language: str="en"
-    google_lang: str="us"
-
-@app.get("/ryuzaki/reverse", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.get("/ryuzaki/reverse", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def google_reverse(
     item: GoogleReverse,
     api_key: None = Depends(validate_api_key)
@@ -463,24 +487,19 @@ 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:
         return {"status": "false", "message": "Internal server error"}
 
-class OrcSpaceUrl(BaseModel):
-    url: str
-    overlay: bool=False
-    language: str="eng"
-
-@app.get("/ryuzaki/ocr", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@app.get("/ryuzaki/ocr", response_model=SuccessResponse, responses={422: {"model": ErrorStatus}})
 def ocr_space_url(
     item: OrcSpaceUrl,
     api_key: None = Depends(validate_api_key)
@@ -500,23 +519,18 @@ 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."
 
-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}})
+@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:
@@ -526,12 +540,12 @@ def chatgpt_model(item: ChatgptModel):
             return f"Error status: {response.status_code}"
         check_response = response.json()
         answer = check_response.get("content")
-        return {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": answer
             }
-        }
+        )
     else:
         params = {"model_id": 5, "prompt": item.query}
         response = requests.post(url, params=params)
@@ -539,43 +553,40 @@ def chatgpt_model(item: ChatgptModel):
             return f"Error status: {response.status_code}"
         check_response = response.json()
         answer = check_response.get("content")
-        return {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": answer
             }
-        }
-
-class ChatgptCustom(BaseModel):
-    query: str
+        )
 
-@app.get("/ryuzaki/freechatgpt-beta", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@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 {
-            "status": "true",
-            "randydev":{
+        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": ErrorResponse}})
+@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 {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": response
             }
-        }
+        )
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.post("/ryuzaki/google-ai", response_model=SuccessResponse, responses={422: {"model": ErrorResponse}})
+@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)
@@ -595,21 +606,16 @@ def v1beta3_google_ai(
         answer = response_str["candidates"]
         for results in answer:
             message = results.get("output")
-        return {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": message
             }
-        }
+        )
     except:
         return {"status": "false", "message": "Error response."}
 
-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}})
+@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)
@@ -638,16 +644,16 @@ def gemini_pro(
         bard = Bard(token=token, session=session, timeout=30)
         bard.get_answer(owner_base)["content"]
         message = bard.get_answer(item.query)["content"]
-        return {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": message
             }
-        }
+        )
     except:
         return {"status": "false", "message": "Error response."}
 
-@app.post("/ryuzaki/v1beta2-google-ai")
+@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)
@@ -666,12 +672,12 @@ def v1beta2_google_ai(
         answer = response_str["candidates"]
         for results in answer:
             message = results.get("content")
-        return {
-            "status": "true",
-            "randydev":{
+        return SuccessResponse(
+            status="True",
+            randydev={
                 "message": message
             }
-        }
+        )
     except:
         return {"status": "false", "message": "Error response."}