Ryzenth 1.8.7__py3-none-any.whl → 1.8.9__py3-none-any.whl

Ryzenth/__version__.py

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

Ryzenth/_asynchisded.py

@@ -22,6 +22,8 @@ import logging
 import httpx
 from box import Box
 
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.helper import FbanAsync, ImagesAsync, ModeratorAsync, WhatAsync, WhisperAsync
 from Ryzenth.types import DownloaderBy, QueryParameter
 
 LOGS = logging.getLogger("[Ryzenth] async")
@@ -31,40 +33,14 @@ 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.images = ImagesAsync(self)
+        self.what = WhatAsync(self)
+        self.openai_audio = WhisperAsync(self)
+        self.federation = FbanAsync(self)
+        self.moderator = ModeratorAsync(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,
@@ -103,13 +79,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,
@@ -146,10 +122,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,6 @@
+class WhatFuckError(Exception):
+    pass
+
+__all__ = [
+  "WhatFuckError"
+]

Ryzenth/_synchisded.py

@@ -22,6 +22,8 @@ import logging
 import httpx
 from box import Box
 
+from Ryzenth._errors import WhatFuckError
+from Ryzenth.helper import FbanSync, ImagesSync, ModeratorSync, WhatSync, WhisperSync
 from Ryzenth.types import DownloaderBy, QueryParameter
 
 LOGS = logging.getLogger("[Ryzenth] sync")
@@ -31,48 +33,14 @@ 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.images = ImagesSync(self)
+        self.what = WhatSync(self)
+        self.openai_audio = WhisperSync(self)
+        self.federation = FbanSync(self)
+        self.moderator = ModeratorSync(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,
@@ -109,13 +77,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,
@@ -151,10 +119,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

@@ -0,0 +1,37 @@
+#!/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/>.
+
+from ._federation import FbanAsync, FbanSync
+from ._images import ImagesAsync, ImagesSync
+from ._moderator import ModeratorAsync, ModeratorSync
+from ._openai import WhisperAsync, WhisperSync
+from ._thinking import WhatAsync, WhatSync
+
+__all__ = [
+  "WhisperAsync",
+  "WhisperSync",
+  "ImagesAsync",
+  "ImagesSync",
+  "WhatAsync",
+  "WhatSync",
+  "FbanAsync",
+  "FbanSync",
+  "ModeratorAsync",
+  "ModeratorSync",
+]

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/_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

@@ -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 OpenaiWhisper
+
+LOGS = logging.getLogger("[Ryzenth]")
+
+class WhisperAsync:
+    def __init__(self, parent):
+            self.parent = parent
+
+    async def whisper_from(self, params: OpenaiWhisper, dot_access=False):
+        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=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 WhisperSync:
+    def __init__(self, parent):
+        self.parent = parent
+
+    def whisper_from(self, params: OpenaiWhisper, dot_access=False):
+        url = f"{self.parent.base_url}/v1/ai/openai/whisper-large-v3-turbo"
+        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 whisper openai {e}")
+            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/types/__init__.py

@@ -28,3 +28,8 @@ class QueryParameter(BaseModel):
 
 class DownloaderBy(BaseModel):
     url: str
+
+class OpenaiWhisper(BaseModel):
+    url: str
+    language: Optional[str] = None
+    task: Optional[str] = None

{ryzenth-1.8.7.dist-info → ryzenth-1.8.9.dist-info}/METADATA

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

ryzenth-1.8.9.dist-info/RECORD

@@ -0,0 +1,18 @@
+Ryzenth/__init__.py,sha256=CKayGQJ_ZUZF6OHyL9kCdTah05BUikXKWKXL_raAgo8,937
+Ryzenth/__version__.py,sha256=jPL75PTvp1TZbA0hDnWqpwC1hH1KuW3f2wqQZbVZgNM,118
+Ryzenth/_asynchisded.py,sha256=pSbv0xKGrJ7oOupMP8fDS6TvWVnkwAc0ILaTOycy6So,4805
+Ryzenth/_client.py,sha256=Y-I1ug8Hf2eF74oDY4eICOTP_nuLXdsDSkyZhpdqZy4,1475
+Ryzenth/_errors.py,sha256=6JwvEAz7SHfJ_6-DkXzwyC5GrdzGr6FtbcIkaRYo9OQ,74
+Ryzenth/_synchisded.py,sha256=LERIcwOWckaF2Tsae0wfjtgHe_yC41rCk1I08AVFpqY,4629
+Ryzenth/helper/__init__.py,sha256=tmJJan2ZVtEy-GHxGwTWuYrP9iYugRuGLjQVnTApZU8,1236
+Ryzenth/helper/_federation.py,sha256=VM1mkuPj4SvlO-VcazIV0T5Ga56RdcpDo7qybXwFCow,13946
+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.8.9.dist-info/licenses/LICENSE,sha256=C73aiGSgoCAVNzvAHs-TROaf5vV8yCj9nqpGrmfNHHo,1068
+ryzenth-1.8.9.dist-info/METADATA,sha256=KZsmokursAmjhKiAl69cntqWRo3QzDotDEoLAcreJdU,4181
+ryzenth-1.8.9.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ryzenth-1.8.9.dist-info/top_level.txt,sha256=0vIhjOjoQuCxLeZO0of8VCx2jsri-bLHV28nh8wWDnc,8
+ryzenth-1.8.9.dist-info/RECORD,,

{ryzenth-1.8.7.dist-info → ryzenth-1.8.9.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.7.dist-info/RECORD

@@ -1,11 +0,0 @@
-Ryzenth/__init__.py,sha256=CKayGQJ_ZUZF6OHyL9kCdTah05BUikXKWKXL_raAgo8,937
-Ryzenth/__version__.py,sha256=y3oVj4a94Xad01PaVSmZEY3iYLp5cn_eJ2km-fRTEbA,118
-Ryzenth/_asynchisded.py,sha256=ySUWEsx4V2lT93OiiPy7RvWHqVuYtm3ySno6ddJYFAM,5804
-Ryzenth/_client.py,sha256=Y-I1ug8Hf2eF74oDY4eICOTP_nuLXdsDSkyZhpdqZy4,1475
-Ryzenth/_synchisded.py,sha256=Et4yIWvsg8UH3_bXBNevnEQzYNkz6F8mj_0W-dQEFI0,5644
-Ryzenth/types/__init__.py,sha256=imnQqDE2egYlFm2_4DRjleLLkFTRthcdZChRBVJvjoc,983
-ryzenth-1.8.7.dist-info/licenses/LICENSE,sha256=C73aiGSgoCAVNzvAHs-TROaf5vV8yCj9nqpGrmfNHHo,1068
-ryzenth-1.8.7.dist-info/METADATA,sha256=fwGlfxqmVbex7WWCWaI9NbWU0PMEk0J-OFeO6tyN7i4,4181
-ryzenth-1.8.7.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-ryzenth-1.8.7.dist-info/top_level.txt,sha256=0vIhjOjoQuCxLeZO0of8VCx2jsri-bLHV28nh8wWDnc,8
-ryzenth-1.8.7.dist-info/RECORD,,