Ryzenth 1.8.8__py3-none-any.whl → 1.9.0__py3-none-any.whl

Ryzenth/__version__.py

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

Ryzenth/_asynchisded.py

@@ -22,7 +22,15 @@ import logging
 import httpx
 from box import Box
 
-from Ryzenth.helper import WhisperAsync
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.helper import (
+    FbanAsync,
+    FontsAsync,
+    ImagesAsync,
+    ModeratorAsync,
+    WhatAsync,
+    WhisperAsync,
+)
 from Ryzenth.types import DownloaderBy, QueryParameter
 
 LOGS = logging.getLogger("[Ryzenth] async")
@@ -32,41 +40,16 @@ class RyzenthXAsync:
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.headers = {"x-api-key": self.api_key}
-        self.images = self.ImagesAsync(self)
-        self.what = self.WhatAsync(self)
+        self.timeout = 10
+        self.params = {}
+        self.images = ImagesAsync(self)
+        self.what = WhatAsync(self)
         self.openai_audio = WhisperAsync(self)
+        self.federation = FbanAsync(self)
+        self.moderator = ModeratorAsync(self)
+        self.fonts = FontsAsync(self)
         self.obj = Box
 
-    class WhatAsync:
-        def __init__(self, parent):
-            self.parent = parent
-
-        async def think(self, params: QueryParameter, dot_access=False):
-            url = f"{self.parent.base_url}/v1/ai/deepseek/deepseek-r1-distill-qwen-32b"
-            async with httpx.AsyncClient() as client:
-                try:
-                    response = await client.get(url, params=params.dict(), headers=self.parent.headers, timeout=30)
-                    response.raise_for_status()
-                    return self.parent.obj(response.json() or {}) if dot_access else response.json()
-                except httpx.HTTPError as e:
-                    LOGS.error(f"[ASYNC] Error: {str(e)}")
-                    return None
-
-    class ImagesAsync:
-        def __init__(self, parent):
-            self.parent = parent
-
-        async def generate(self, params: QueryParameter):
-            url = f"{self.parent.base_url}/v1/flux/black-forest-labs/flux-1-schnell"
-            async with httpx.AsyncClient() as client:
-                try:
-                    response = await client.get(url, params=params.dict(), headers=self.parent.headers, timeout=30)
-                    response.raise_for_status()
-                    return response.content
-                except httpx.HTTPError as e:
-                    LOGS.error(f"[ASYNC] Error: {str(e)}")
-                    return None
-
     async def send_downloader(
         self,
         switch_name: str = None,
@@ -105,13 +88,13 @@ class RyzenthXAsync:
                     f"{self.base_url}/v1/dl/{model_name}",
                     params=params.dict(),
                     headers=self.headers,
-                    timeout=10
+                    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"[ASYNC] Error: {str(e)}")
-                return None
+                raise WhatFuckError("[ASYNC] Error fetching") from e
 
     async def send_message(
         self,
@@ -148,10 +131,10 @@ class RyzenthXAsync:
                     f"{self.base_url}/v1/ai/akenox/{model_param}",
                     params=params.dict(),
                     headers=self.headers,
-                    timeout=10
+                    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"[ASYNC] Error: {str(e)}")
-                return None
+                raise WhatFuckError("[ASYNC] Error fetching") from e

Ryzenth/_errors.py

@@ -0,0 +1,10 @@
+class WhatFuckError(Exception):
+    pass
+
+class ErrorParamsRequired(ValueError):
+    pass
+
+__all__ = [
+    "WhatFuckError",
+    "ErrorParamsRequired"
+]

Ryzenth/_synchisded.py

@@ -22,7 +22,8 @@ import logging
 import httpx
 from box import Box
 
-from Ryzenth.helper import WhisperSync
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.helper import FbanSync, FontsSync, ImagesSync, ModeratorSync, WhatSync, WhisperSync
 from Ryzenth.types import DownloaderBy, QueryParameter
 
 LOGS = logging.getLogger("[Ryzenth] sync")
@@ -32,49 +33,16 @@ class RyzenthXSync:
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.headers = {"x-api-key": self.api_key}
-        self.images = self.ImagesSync(self)
-        self.what = self.WhatSync(self)
+        self.timeout = 10
+        self.params = {}
+        self.images = ImagesSync(self)
+        self.what = WhatSync(self)
         self.openai_audio = WhisperSync(self)
+        self.federation = FbanSync(self)
+        self.moderator = ModeratorSync(self)
+        self.fonts = FontsSync(self)
         self.obj = Box
 
-    class WhatSync:
-        def __init__(self, parent):
-            self.parent = parent
-
-        def think(self, params: QueryParameter, dot_access=False):
-            url = f"{self.parent.base_url}/v1/ai/deepseek/deepseek-r1-distill-qwen-32b"
-            try:
-                response = httpx.get(
-                    url,
-                    params=params.dict(),
-                    headers=self.parent.headers,
-                    timeout=30
-                )
-                response.raise_for_status()
-                return self.parent.obj(response.json() or {}) if dot_access else response.json()
-            except httpx.HTTPError as e:
-                LOGS.error(f"[SYNC] Error fetching from deepseek {e}")
-                return None
-
-    class ImagesSync:
-        def __init__(self, parent):
-            self.parent = parent
-
-        def generate(self, params: QueryParameter):
-            url = f"{self.parent.base_url}/v1/flux/black-forest-labs/flux-1-schnell"
-            try:
-                response = httpx.get(
-                    url,
-                    params=params.dict(),
-                    headers=self.parent.headers,
-                    timeout=30
-                )
-                response.raise_for_status()
-                return response.content
-            except httpx.HTTPError as e:
-                LOGS.error(f"[SYNC] Error fetching from images {e}")
-                return None
-
     def send_downloader(
         self,
         switch_name: str = None,
@@ -111,13 +79,13 @@ class RyzenthXSync:
                 f"{self.base_url}/v1/dl/{model_name}",
                 params=params.dict(),
                 headers=self.headers,
-                timeout=10
+                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}")
-            return None
+            raise WhatFuckError("[SYNC] Error fetching from downloader") from e
 
     def send_message(
         self,
@@ -153,10 +121,10 @@ class RyzenthXSync:
                 f"{self.base_url}/v1/ai/akenox/{model_param}",
                 params=params.dict(),
                 headers=self.headers,
-                timeout=10
+                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}")
-            return None
+            raise WhatFuckError("[SYNC] Error fetching from akenox") from e

Ryzenth/helper/__init__.py

@@ -17,9 +17,24 @@
 # 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/>.
 
+from ._federation import FbanAsync, FbanSync
+from ._fonts import FontsAsync, FontsSync
+from ._images import ImagesAsync, ImagesSync
+from ._moderator import ModeratorAsync, ModeratorSync
 from ._openai import WhisperAsync, WhisperSync
+from ._thinking import WhatAsync, WhatSync
 
 __all__ = [
   "WhisperAsync",
-  "WhisperSync"
+  "WhisperSync",
+  "ImagesAsync",
+  "ImagesSync",
+  "WhatAsync",
+  "WhatSync",
+  "FbanAsync",
+  "FbanSync",
+  "ModeratorAsync",
+  "ModeratorSync",
+  "FontsAsync",
+  "FontsSync"
 ]

Ryzenth/helper/_federation.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# 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 logging
+
+import httpx
+
+from Ryzenth._errors import WhatFuckError
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class FbanSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def newfed(self, name: str , owner: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/newfed"
+        try:
+            response = httpx.post(
+                url,
+                json={"name": name, "owner": owner},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from newfed {e}")
+            raise WhatFuckError("[SYNC] Error fetching from newfed") from e
+
+    def subfed(self, parent_uuid: str, child_uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/subfed"
+        try:
+            response = httpx.post(
+                url,
+                json={"parent_uuid": parent_uuid, "child_uuid": child_uuid},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from subfed {e}")
+            raise WhatFuckError("[SYNC] Error fetching from subfed") from e
+
+    def getfed(self, uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/getfed/{uuid}"
+        try:
+            response = httpx.get(
+                url,
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from getfed {e}")
+            raise WhatFuckError("[SYNC] Error fetching from getfed") from e
+
+    def unban(self, name: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/unban"
+        try:
+            response = httpx.post(
+                url,
+                json={"name": name, "user_id": user_id},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from unban {e}")
+            raise WhatFuckError("[SYNC] Error fetching from unban") from e
+
+    def ban(self, federation_uuid: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/ban"
+        try:
+            response = httpx.post(
+                url,
+                json={"federation_uuid": federation_uuid, "user_id": user_id},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from unban {e}")
+            raise WhatFuckError("[SYNC] Error fetching from unban") from e
+
+    def ban_check(self, federation_uuid: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/ban-check"
+        try:
+            response = httpx.post(
+                url,
+                json={"federation_uuid": federation_uuid, "user_id": user_id},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from ban-check {e}")
+            raise WhatFuckError("[SYNC] Error fetching from ban-check") from e
+
+    def fedstats(self, uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/fedstats"
+        try:
+            response = httpx.get(
+                url,
+                params={"uuid": uuid},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from fedstats {e}")
+            raise WhatFuckError("[SYNC] Error fetching from fedstats") from e
+
+    def unsubfed(self, parent_uuid: str, child_uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/unsubfed"
+        try:
+            response = httpx.post(
+                url,
+                json={"parent_uuid": parent_uuid, "child_uuid": child_uuid},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from unsubfed {e}")
+            raise WhatFuckError("[SYNC] Error fetching from unsubfed") from e
+
+    def renamefed(self, federation_uuid: str, new_name: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/renamefed"
+        try:
+            response = httpx.post(
+                url,
+                json={"federation_uuid": federation_uuid, "new_name": new_name},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from renamefed {e}")
+            raise WhatFuckError("[SYNC] Error fetching from renamefed") from e
+
+class FbanAsync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    async def newfed(self, name: str , owner: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/newfed"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"name": name, "owner": owner},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def subfed(self, parent_uuid: str, child_uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/subfed"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"parent_uuid": parent_uuid, "child_uuid": child_uuid},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def getfed(self, uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/getfed/{uuid}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url, headers=self.parent.headers, timeout=self.parent.timeout)
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def unban(self, name: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/unban"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"name": name, "user_id": user_id},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def ban(self, federation_uuid: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/ban"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"federation_uuid": federation_uuid, "user_id": user_id},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def ban_check(self, federation_uuid: str, user_id: int, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/ban-check"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"federation_uuid": federation_uuid, "user_id": user_id},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def fedstats(self, uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/fedstats"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    url,
+                    params={"uuid": uuid},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def unsubfed(self, parent_uuid: str, child_uuid: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/unsubfed"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"parent_uuid": parent_uuid, "child_uuid": child_uuid},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+    async def renamefed(self, federation_uuid: str, new_name: str, dot_access=False):
+        url = f"{self.parent.base_url}/v2/federation/renamefed"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    url,
+                    json={"federation_uuid": federation_uuid, "new_name": new_name},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e

Ryzenth/helper/_fonts.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# 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 json
+import logging
+from datetime import datetime as dt
+
+import httpx
+
+from Ryzenth._errors import ErrorParamsRequired, WhatFuckError
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class FontsAsync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    async def scanning(
+        self,
+        text: str = None,
+        dot_access=False
+    ):
+        url = f"{self.parent.base_url}/v1/fonts-stylish/detected"
+        if not text:
+            raise ErrorParamsRequired("Invalid Params Text")
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    url,
+                    params={"query": text},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+class FontsSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def scanning(
+        self,
+        text: str = None,
+        dot_access=False
+    ):
+        url = f"{self.parent.base_url}/v1/fonts-stylish/detected"
+        if not text:
+            raise ErrorParamsRequired("Invalid Params Text")
+        try:
+            response = httpx.get(
+                url,
+                params={"query": text},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from fonts {e}")
+            raise WhatFuckError("[SYNC] Error fetching from fonts") from e

Ryzenth/helper/_images.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# 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 logging
+
+import httpx
+
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.types import QueryParameter
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class ImagesAsync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    async def generate(self, params: QueryParameter):
+        url = f"{self.parent.base_url}/v1/flux/black-forest-labs/flux-1-schnell"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(url, params=params.dict(), headers=self.parent.headers, timeout=self.parent.timeout)
+                response.raise_for_status()
+                return response.content
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+class ImagesSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def generate(self, params: QueryParameter):
+        url = f"{self.parent.base_url}/v1/flux/black-forest-labs/flux-1-schnell"
+        try:
+            response = httpx.get(
+                url,
+                params=params.dict(),
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return response.content
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from images {e}")
+            raise WhatFuckError("[SYNC] Error fetching from images") from e

Ryzenth/helper/_moderator.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# 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 json
+import logging
+from datetime import datetime as dt
+
+import httpx
+
+from Ryzenth._errors import WhatFuckError
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class ModeratorAsync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    async def antievalai(
+        self,
+        query: str,
+        version: str,
+        to_dict_by_loads=False,
+        dot_access=False
+    ):
+        version_params = {
+            "v1": "v1",
+            "v2": "v2"
+        }
+        _version = version_params.get(version)
+        if not _version:
+            raise ValueError("Invalid Version Name")
+
+        url = f"{self.parent.base_url}/v1/ai/akenox/antievalai-{_version}"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    url,
+                    params={"query": query},
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                if to_dict_by_loads:
+                    try:
+                        return {
+                            "author": "TeamKillerX",
+                            f"timestamps": dt.now(),
+                            f"is_detect": json.loads(response.json()["results"])["is_detect"],
+                            "source": "Powered by Ryzenth API"
+                        }
+                    except json.decoder.JSONDecodeError:
+                        return {
+                            "author": "TeamKillerX",
+                            f"timestamps": dt.now(),
+                            f"is_detect": False,
+                            "source": "Powered by Ryzenth API"
+                        }
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+class ModeratorSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def antievalai(
+        self,
+        query: str,
+        version: str,
+        to_dict_by_loads=False,
+        dot_access=False
+    ):
+        version_params = {
+            "v1": "v1",
+            "v2": "v2"
+        }
+        _version = version_params.get(version)
+        if not _version:
+            raise ValueError("Invalid Version Name")
+
+        url = f"{self.parent.base_url}/v1/ai/akenox/antievalai-{_version}"
+        try:
+            response = httpx.get(
+                url,
+                params={"query": query},
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            if to_dict_by_loads:
+                try:
+                    return {
+                        "author": "TeamKillerX",
+                        f"timestamps": dt.now(),
+                        f"is_detect": json.loads(response.json()["results"])["is_detect"],
+                        "source": "Powered by Ryzenth API"
+                    }
+                except json.decoder.JSONDecodeError:
+                    return {
+                        "author": "TeamKillerX",
+                        f"timestamps": dt.now(),
+                        f"is_detect": False,
+                        "source": "Powered by Ryzenth API"
+                    }
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from antievalai {e}")
+            raise WhatFuckError("[SYNC] Error fetching from antievalai") from e

Ryzenth/helper/_openai.py

@@ -21,6 +21,7 @@ import logging
 
 import httpx
 
+from Ryzenth._errors import WhatFuckError
 from Ryzenth.types import OpenaiWhisper
 
 LOGS = logging.getLogger("[Ryzenth]")
@@ -33,12 +34,17 @@ class WhisperAsync:
         url = f"{self.parent.base_url}/v1/ai/openai/whisper-large-v3-turbo"
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.get(url, params=params.dict(), headers=self.parent.headers, timeout=30)
+                response = await client.get(
+                    url,
+                    params=params.dict(),
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
                 response.raise_for_status()
                 return self.parent.obj(response.json() or {}) if dot_access else response.json()
             except httpx.HTTPError as e:
                 LOGS.error(f"[ASYNC] Error: {str(e)}")
-                return None
+                raise WhatFuckError("[ASYNC] Error fetching") from e
 
 class WhisperSync:
     def __init__(self, parent):
@@ -51,10 +57,10 @@ class WhisperSync:
                 url,
                 params=params.dict(),
                 headers=self.parent.headers,
-                timeout=30
+                timeout=self.parent.timeout
             )
             response.raise_for_status()
             return self.parent.obj(response.json() or {}) if dot_access else response.json()
         except httpx.HTTPError as e:
             LOGS.error(f"[SYNC] Error fetching from whisper openai {e}")
-            return None
+            raise WhatFuckError("[SYNC] Error fetching from whisper openai") from e

Ryzenth/helper/_thinking.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# 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 logging
+
+import httpx
+
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.types import QueryParameter
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class WhatAsync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    async def think(self, params: QueryParameter, dot_access=False):
+        url = f"{self.parent.base_url}/v1/ai/deepseek/deepseek-r1-distill-qwen-32b"
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(
+                    url,
+                    params=params.dict(),
+                    headers=self.parent.headers,
+                    timeout=self.parent.timeout
+                )
+                response.raise_for_status()
+                return self.parent.obj(response.json() or {}) if dot_access else response.json()
+            except httpx.HTTPError as e:
+                LOGS.error(f"[ASYNC] Error: {str(e)}")
+                raise WhatFuckError("[ASYNC] Error fetching") from e
+
+class WhatSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def think(self, params: QueryParameter, dot_access=False):
+        url = f"{self.parent.base_url}/v1/ai/deepseek/deepseek-r1-distill-qwen-32b"
+        try:
+            response = httpx.get(
+                url,
+                params=params.dict(),
+                headers=self.parent.headers,
+                timeout=self.parent.timeout
+            )
+            response.raise_for_status()
+            return self.parent.obj(response.json() or {}) if dot_access else response.json()
+        except httpx.HTTPError as e:
+            LOGS.error(f"[SYNC] Error fetching from deepseek {e}")
+            raise WhatFuckError("[SYNC] Error fetching from deepseek") from e

{ryzenth-1.8.8.dist-info → ryzenth-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Ryzenth
-Version: 1.8.8
+Version: 1.9.0
 Summary: Ryzenth Python Wrapper For Perfomance
 Author: TeamKillerX
 License: MIT

ryzenth-1.9.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+Ryzenth/__init__.py,sha256=CKayGQJ_ZUZF6OHyL9kCdTah05BUikXKWKXL_raAgo8,937
+Ryzenth/__version__.py,sha256=twdc5C08GfAEZJ_2vw8Vu9ivAX2v2en0u5F_RcOWe_w,118
+Ryzenth/_asynchisded.py,sha256=ZNLp1rOJ_4SYcyMeB02ybsSmU38GO0TpHsQHRiR2w6c,4909
+Ryzenth/_client.py,sha256=Y-I1ug8Hf2eF74oDY4eICOTP_nuLXdsDSkyZhpdqZy4,1475
+Ryzenth/_errors.py,sha256=_ViAlLpyKIEM5b2NQHNw8ftAvm80g7Rrv1QHWNAQ5LI,152
+Ryzenth/_synchisded.py,sha256=KFO3Smy3qKhOPW9cVQ6uutspDZjiZz79hiLaXFgGRfA,4702
+Ryzenth/helper/__init__.py,sha256=ANx8vCXJ9ReLXIDWUwyhrIbw7jIyUXMdP11qotrWWIE,1308
+Ryzenth/helper/_federation.py,sha256=VM1mkuPj4SvlO-VcazIV0T5Ga56RdcpDo7qybXwFCow,13946
+Ryzenth/helper/_fonts.py,sha256=jrZ_wTZiXuN8AbqrT8bqc09naEkEJqQ8AdA16e_rqlk,2767
+Ryzenth/helper/_images.py,sha256=AfNQoxae-yI76PDUa-jx7tWBlJa4tRZQFDjeqBLKwVM,2309
+Ryzenth/helper/_moderator.py,sha256=BCZ97DntbMaPmKKWZOPf0W9GjcxzwM2y1N9PqgRPT2w,4518
+Ryzenth/helper/_openai.py,sha256=hUhmwxuKV-AAeEbDFm4RnkasHNJjFROLdw1q2j2t_Mc,2574
+Ryzenth/helper/_thinking.py,sha256=BKHvQe16KPOGh7_vev-_Ed8jl6_77_8Ys-g0SDtvlSU,2557
+Ryzenth/types/__init__.py,sha256=3eEOjoRcEPoE5J5oIhXEPH6vbYG7TLasTHFcbWGS-mU,1095
+ryzenth-1.9.0.dist-info/licenses/LICENSE,sha256=C73aiGSgoCAVNzvAHs-TROaf5vV8yCj9nqpGrmfNHHo,1068
+ryzenth-1.9.0.dist-info/METADATA,sha256=01OPOveR6quHQidtFmdMvKCX-V2Ii0vFOM-Z8MvpZWU,4181
+ryzenth-1.9.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ryzenth-1.9.0.dist-info/top_level.txt,sha256=0vIhjOjoQuCxLeZO0of8VCx2jsri-bLHV28nh8wWDnc,8
+ryzenth-1.9.0.dist-info/RECORD,,

{ryzenth-1.8.8.dist-info → ryzenth-1.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ryzenth-1.8.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-Ryzenth/__init__.py,sha256=CKayGQJ_ZUZF6OHyL9kCdTah05BUikXKWKXL_raAgo8,937
-Ryzenth/__version__.py,sha256=WMw0ZhFbEu7caaKIRyF0MQHhrdWDRzwYZgq3FyCRvTw,118
-Ryzenth/_asynchisded.py,sha256=zt7bV3aieGreQULEwLmuwUt6amYrqht1BRB1dWBPEyA,5891
-Ryzenth/_client.py,sha256=Y-I1ug8Hf2eF74oDY4eICOTP_nuLXdsDSkyZhpdqZy4,1475
-Ryzenth/_synchisded.py,sha256=hTRlIsTXltDurPUbhx4a4o6VPOrX2bf-gLMIQYWFhlU,5729
-Ryzenth/helper/__init__.py,sha256=7EyYKljsMHWs7mkj7_zhPuOxo3evXS513tLbW2oezkI,918
-Ryzenth/helper/_openai.py,sha256=p79Ed_IMHeW69KCVxOiEB80h9fBzNLXXEeghkrphL8w,2299
-Ryzenth/types/__init__.py,sha256=3eEOjoRcEPoE5J5oIhXEPH6vbYG7TLasTHFcbWGS-mU,1095
-ryzenth-1.8.8.dist-info/licenses/LICENSE,sha256=C73aiGSgoCAVNzvAHs-TROaf5vV8yCj9nqpGrmfNHHo,1068
-ryzenth-1.8.8.dist-info/METADATA,sha256=OsHC_PluVNRpNgngga__8XtAvnafun9wNs4EuZQCrJQ,4181
-ryzenth-1.8.8.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-ryzenth-1.8.8.dist-info/top_level.txt,sha256=0vIhjOjoQuCxLeZO0of8VCx2jsri-bLHV28nh8wWDnc,8
-ryzenth-1.8.8.dist-info/RECORD,,