Ryzenth 1.9.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

Ryzenth/__version__.py

@@ -1,4 +1,4 @@
-__version__ = "1.9.6"
+__version__ = "2.0.0"
 __author__ = "TeamKillerX"
 __title__ = "Ryzenth"
 __description__ = "Ryzenth Python API Wrapper"

Ryzenth/_asynchisded.py

@@ -18,11 +18,13 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import logging
+from typing import Union
 
 import httpx
 from box import Box
 
-from ._errors import WhatFuckError
+from ._errors import InvalidModelError, WhatFuckError
+from ._shared import BASE_DICT_AI_RYZENTH, BASE_DICT_OFFICIAL, BASE_DICT_RENDER
 from .helper import (
     FbanAsync,
     FontsAsync,
@@ -34,7 +36,6 @@ from .helper import (
 )
 from .types import DownloaderBy, QueryParameter
 
-LOGS = logging.getLogger("[Ryzenth] async")
 
 class RyzenthXAsync:
     def __init__(self, api_key: str, base_url: str = "https://randydev-ryu-js.hf.space/api"):
@@ -51,92 +52,75 @@ class RyzenthXAsync:
         self.fonts = FontsAsync(self)
         self.humanizer = HumanizeAsync(self)
         self.obj = Box
+        self.httpx = httpx
+        self.logger = logging.getLogger("Ryzenth Bot")
+        self.logger.setLevel(logging.INFO)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+        if not self.logger.handlers:
+            handler = logging.FileHandler("RyzenthLib.log", encoding="utf-8")
+            handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            self.logger.addHandler(handler)
 
     async def send_downloader(
         self,
-        switch_name: str = None,
-        params: DownloaderBy = None,
-        list_key=False,
+        switch_name: str,
+        *,
+        params: Union[DownloaderBy, QueryParameter] = None,
+        on_render=False,
         dot_access=False
     ):
-        dl_dict = {
-            "teraboxv4": "terabox-v4",
-            "twitterv3": "twitter-v3",
-            "xnxxinfov2": "xnxx-info-v2",
-            "instagramv4": "instagram-v4",
-            "instagramv3": "instagram-v3",
-            "instagramv2": "instagram-v2",
-            "instagram": "instagram",
-            "twitter": "twitter",
-            "tiktok": "tiktok",
-            "tiktokv2": "tiktok-v2",
-            "facebook": "fb",
-            "snapsave": "snapsave",
-            "savefrom": "savefrom"
-        }
-        if list_key:
-            return list(dl_dict.keys())
-
-        if not switch_name:
-            raise ValueError("`switch_name` is required. Use `list_key=True` to see all valid options.")
 
+        dl_dict = BASE_DICT_RENDER if on_render else BASE_DICT_OFFICIAL
         model_name = dl_dict.get(switch_name)
         if not model_name:
-            raise ValueError(f"Invalid switch_name: {switch_name}")
+            raise InvalidModelError(f"Invalid switch_name: {switch_name}")
 
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.get(
-                    f"{self.base_url}/v1/dl/{model_name}",
-                    params=params.dict(),
-                    headers=self.headers,
-                    timeout=self.timeout
-                )
+                response = await self._client_downloader_get(client, params, model_name)
                 response.raise_for_status()
                 return self.obj(response.json() or {}) if dot_access else response.json()
             except httpx.HTTPError as e:
-                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                self.logger.error(f"[ASYNC] Error: {str(e)}")
                 raise WhatFuckError("[ASYNC] Error fetching") from e
 
+    async def _client_message_get(self, client, params, model_param):
+        return await client.get(
+            f"{self.base_url}/v1/ai/akenox/{model_param}",
+            params=params.model_dump(),
+            headers=self.headers,
+            timeout=self.timeout
+        )
+
+    async def _client_downloader_get(self, client, params, model_param):
+        return await client.get(
+            f"{self.base_url}/v1/dl/{model_param}",
+            params=params.model_dump(),
+            headers=self.headers,
+            timeout=self.timeout
+        )
+
     async def send_message(
         self,
-        model: str = None,
+        model: str,
+        *,
         params: QueryParameter = None,
-        list_key=False,
+        use_full_model_list=False,
         dot_access=False
     ):
-        model_dict = {
-            "hybrid": "AkenoX-1.9-Hybrid",
-            "hybrid-english": "AkenoX-1.9-Hybrid-Englsih",
-            "melayu": "lu-melayu",
-            "nocodefou": "nocodefou",
-            "mia": "mia-khalifah",
-            "curlmcode": "curl-command-code",
-            "quotessad": "quotes-sad",
-            "quoteslucu": "quotes-lucu",
-            "lirikend": "lirik-end",
-            "alsholawat": "al-sholawat"
-        }
-        if list_key:
-            return list(model_dict.keys())
-
-        if not model:
-            raise ValueError("`model` is required. Use `list_key=True` to see all valid options.")
 
+        model_dict = BASE_DICT_AI_RYZENTH if use_full_model_list else {"hybrid": "AkenoX-1.9-Hybrid"}
         model_param = model_dict.get(model)
+
         if not model_param:
-            raise ValueError(f"Invalid model name: {model}")
+            raise InvalidModelError(f"Invalid model name: {model}")
 
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.get(
-                    f"{self.base_url}/v1/ai/akenox/{model_param}",
-                    params=params.dict(),
-                    headers=self.headers,
-                    timeout=self.timeout
-                )
+                response = await self._client_message_get(client, params, model_param)
                 response.raise_for_status()
                 return self.obj(response.json() or {}) if dot_access else response.json()
             except httpx.HTTPError as e:
-                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                self.logger.error(f"[ASYNC] Error: {str(e)}")
                 raise WhatFuckError("[ASYNC] Error fetching") from e

Ryzenth/_errors.py

@@ -26,6 +26,15 @@ class WhatFuckError(Exception):
 class ParamsRequiredError(ValueError):
     pass
 
+class RequiredError(ValueError):
+    pass
+
+class InvalidModelError(ValueError):
+    pass
+
+class UnauthorizedAccessError(ValueError):
+    pass
+
 class InvalidVersionError(ValueError):
     pass
 
@@ -40,5 +49,8 @@ __all__ = [
     "ParamsRequiredError",
     "InvalidVersionError",
     "InvalidJSONDecodeError",
-    "InvalidEmptyError"
+    "InvalidEmptyError",
+    "InvalidModelError",
+    "UnauthorizedAccessError",
+    "RequiredError"
 ]

Ryzenth/_shared.py

@@ -0,0 +1,46 @@
+# this API is different
+
+BASE_DICT_RENDER = {
+    "transcript": "transcript-dl", #url #render
+    "pinterest": "pinterest-dl", #url #render
+    "fbvideo": "fbvideo-dl", #url #render
+    "fbphoto": "fbphoto-dl", #url #render
+    "tiktok": "tiktok-dl", #url #render
+    "youtube-mp3": "youtube-mp3-dl", #url #render
+    "youtube-mp4": "youtube-mp4-dl", #url #render
+    "instagram": "instagram-dl", #url # render
+    "lyrics-search": "lyrics-search-dl", #query #render
+    "yt-search": "yt-search-dl", #query #render
+    "google-search": "google-search-dl", #query #render
+    "pinterest-search": "pinterest-search-dl", #query #render
+    "tiktok-search": "tiktok-search-dl" #query #render
+}
+
+BASE_DICT_OFFICIAL = {
+    "teraboxv4": "terabox-v4",
+    "twitterv3": "twitter-v3",
+    "xnxxinfov2": "xnxx-info-v2",
+    "instagramv4": "instagram-v4",
+    "instagramv3": "instagram-v3",
+    "instagramv2": "instagram-v2",
+    "instagram-v0": "instagram",
+    "twitter": "twitter",
+    "tiktok-v0": "tiktok",
+    "tiktokv2": "tiktok-v2",
+    "facebook": "fb",
+    "snapsave": "snapsave",
+    "savefrom": "savefrom"
+}
+
+BASE_DICT_AI_RYZENTH = {
+    "hybrid": "AkenoX-1.9-Hybrid",
+    "hybrid-english": "AkenoX-1.9-Hybrid-English",
+    "melayu": "lu-melayu",
+    "nocodefou": "nocodefou",
+    "mia": "mia-khalifah",
+    "curlmcode": "curl-command-code",
+    "quotessad": "quotes-sad",
+    "quoteslucu": "quotes-lucu",
+    "lirikend": "lirik-end",
+    "alsholawat": "al-sholawat"
+}

Ryzenth/_synchisded.py

@@ -18,11 +18,13 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import logging
+from typing import Union
 
 import httpx
 from box import Box
 
-from ._errors import WhatFuckError
+from ._errors import InvalidModelError, WhatFuckError
+from ._shared import BASE_DICT_AI_RYZENTH, BASE_DICT_OFFICIAL, BASE_DICT_RENDER
 from .helper import (
     FbanSync,
     FontsSync,
@@ -34,7 +36,6 @@ from .helper import (
 )
 from .types import DownloaderBy, QueryParameter
 
-LOGS = logging.getLogger("[Ryzenth] sync")
 
 class RyzenthXSync:
     def __init__(self, api_key: str, base_url: str = "https://randydev-ryu-js.hf.space/api"):
@@ -51,89 +52,69 @@ class RyzenthXSync:
         self.fonts = FontsSync(self)
         self.humanizer = HumanizeSync(self)
         self.obj = Box
+        self.httpx = httpx
+        self.logger = logging.getLogger("Ryzenth Bot")
+        self.logger.setLevel(logging.INFO)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+        if not self.logger.handlers:
+            handler = logging.FileHandler("RyzenthLib.log", encoding="utf-8")
+            handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            self.logger.addHandler(handler)
 
     def send_downloader(
         self,
-        switch_name: str = None,
-        params: DownloaderBy = None,
-        list_key=False,
+        switch_name: str,
+        *,
+        params: Union[DownloaderBy, QueryParameter] = None,
+        on_render=False,
         dot_access=False
     ):
-        dl_dict = {
-            "teraboxv4": "terabox-v4",
-            "twitterv3": "twitter-v3",
-            "xnxxinfov2": "xnxx-info-v2",
-            "instagramv4": "instagram-v4",
-            "instagramv3": "instagram-v3",
-            "instagramv2": "instagram-v2",
-            "instagram": "instagram",
-            "twitter": "twitter",
-            "tiktok": "tiktok",
-            "tiktokv2": "tiktok-v2",
-            "facebook": "fb",
-            "snapsave": "snapsave",
-            "savefrom": "savefrom"
-        }
-        if list_key:
-            return list(dl_dict.keys())
-
-        if not switch_name:
-            raise ValueError("`switch_name` is required. Use `list_key=True` to see all valid options.")
-
+        dl_dict = BASE_DICT_RENDER if on_render else BASE_DICT_OFFICIAL
         model_name = dl_dict.get(switch_name)
         if not model_name:
-            raise ValueError(f"Invalid switch_name: {switch_name}")
+            raise InvalidModelError(f"Invalid switch_name: {switch_name}")
         try:
             response = httpx.get(
                 f"{self.base_url}/v1/dl/{model_name}",
-                params=params.dict(),
+                params=params.model_dump(),
                 headers=self.headers,
                 timeout=self.timeout
             )
             response.raise_for_status()
             return self.obj(response.json() or {}) if dot_access else response.json()
         except httpx.HTTPError as e:
-            LOGS.error(f"[SYNC] Error fetching from downloader {e}")
+            self.logger.error(f"[SYNC] Error fetching from downloader {e}")
             raise WhatFuckError("[SYNC] Error fetching from downloader") from e
+        except httpx.ReadTimeout as e:
+            self.logger.error(f"[SYNC] Error ReadTimeout from downloader {e}")
+            raise WhatFuckError("[SYNC] Error ReadTimeout from downloader ") from e
 
     def send_message(
         self,
-        model: str = None,
+        model: str,
+        *,
         params: QueryParameter = None,
-        list_key=False,
+        use_full_model_list=False,
         dot_access=False
     ):
-        model_dict = {
-            "hybrid": "AkenoX-1.9-Hybrid",
-            "hybrid-english": "AkenoX-1.9-Hybrid-Englsih",
-            "melayu": "lu-melayu",
-            "nocodefou": "nocodefou",
-            "mia": "mia-khalifah",
-            "curlmcode": "curl-command-code",
-            "quotessad": "quotes-sad",
-            "quoteslucu": "quotes-lucu",
-            "lirikend": "lirik-end",
-            "alsholawat": "al-sholawat"
-        }
-        if list_key:
-            return list(model_dict.keys())
-
-        if not model:
-            raise ValueError("`model` is required. Use `list_key=True` to see all valid options.")
-
+        model_dict = BASE_DICT_AI_RYZENTH if use_full_model_list else {"hybrid": "AkenoX-1.9-Hybrid"}
         model_param = model_dict.get(model)
         if not model_param:
-            raise ValueError(f"Invalid model name: {model}")
+            raise InvalidModelError(f"Invalid model name: {model}")
 
         try:
             response = httpx.get(
                 f"{self.base_url}/v1/ai/akenox/{model_param}",
-                params=params.dict(),
+                params=params.model_dump(),
                 headers=self.headers,
                 timeout=self.timeout
             )
             response.raise_for_status()
             return self.obj(response.json() or {}) if dot_access else response.json()
         except httpx.HTTPError as e:
-            LOGS.error(f"[SYNC] Error fetching from akenox: {e}")
+            self.logger.error(f"[SYNC] Error fetching from akenox: {e}")
             raise WhatFuckError("[SYNC] Error fetching from akenox") from e
+        except httpx.ReadTimeout as e:
+            self.logger.error(f"[SYNC] Error ReadTimeout from Akenox {e}")
+            raise WhatFuckError("[SYNC] Error ReadTimeout from akenox") from e

Ryzenth/helper/_decorators.py

@@ -40,7 +40,10 @@ class Decorators:
                         "Please provide a query after the command.", **kwargs
                     )
                 result = await self._clients_ai.aio.send_message(
-                    name, QueryParameter(query=query), dot_access=True
+                    model=name,
+                    params=QueryParameter(query=query),
+                    use_full_model_list=True,
+                    dot_access=True
                 )
                 await message.reply_text(result.results, **kwargs)
                 return await func(client, message, query, *args, **kwargs)