beswarm 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

beswarm/aient/src/aient/models/__init__.py

@@ -0,0 +1,9 @@
+from .chatgpt import *
+from .claude import *
+from .gemini import *
+from .vertex import *
+from .groq import *
+from .audio import *
+from .duckduckgo import *
+
+# __all__ = ["chatgpt", "claude", "claude3", "gemini", "groq"]

beswarm/aient/src/aient/models/audio.py

@@ -0,0 +1,63 @@
+import os
+import requests
+import json
+from .base import BaseLLM
+
+API = os.environ.get('API', None)
+API_URL = os.environ.get('API_URL', None)
+
+class whisper(BaseLLM):
+    def __init__(
+        self,
+        api_key: str,
+        api_url: str = (os.environ.get("API_URL") or "https://api.openai.com/v1/audio/transcriptions"),
+        timeout: float = 20,
+    ):
+        super().__init__(api_key, api_url=api_url, timeout=timeout)
+        self.engine: str = "whisper-1"
+
+    def generate(
+        self,
+        audio_file: bytes,
+        model: str = "whisper-1",
+        **kwargs,
+    ):
+        url = self.api_url.audio_transcriptions
+        headers = {"Authorization": f"Bearer {kwargs.get('api_key', self.api_key)}"}
+
+        files = {
+            "file": ("audio.mp3", audio_file, "audio/mpeg")
+        }
+
+        data = {
+            "model": os.environ.get("AUDIO_MODEL_NAME") or model or self.engine,
+        }
+        try:
+            response = self.session.post(
+                url,
+                headers=headers,
+                data=data,
+                files=files,
+                timeout=kwargs.get("timeout", self.timeout),
+                stream=True,
+            )
+        except ConnectionError:
+            print("连接错误，请检查服务器状态或网络连接。")
+            return
+        except requests.exceptions.ReadTimeout:
+            print("请求超时，请检查网络连接或增加超时时间。{e}")
+            return
+        except Exception as e:
+            print(f"发生了未预料的错误: {e}")
+            return
+
+        if response.status_code != 200:
+            raise Exception(f"{response.status_code} {response.reason} {response.text}")
+        json_data = json.loads(response.text)
+        text = json_data["text"]
+        return text
+
+def audio_transcriptions(text):
+    dallbot = whisper(api_key=f"{API}")
+    for data in dallbot.generate(text):
+        return data

beswarm/aient/src/aient/models/base.py

@@ -0,0 +1,251 @@
+import os
+import httpx
+import requests
+from pathlib import Path
+from collections import defaultdict
+
+from ..utils import prompt
+from ..core.utils import BaseAPI
+
+class BaseLLM:
+    def __init__(
+        self,
+        api_key: str = None,
+        engine: str = os.environ.get("GPT_ENGINE") or "gpt-3.5-turbo",
+        api_url: str = (os.environ.get("API_URL", None) or "https://api.openai.com/v1/chat/completions"),
+        system_prompt: str = prompt.chatgpt_system_prompt,
+        proxy: str = None,
+        timeout: float = 600,
+        max_tokens: int = None,
+        temperature: float = 0.5,
+        top_p: float = 1.0,
+        presence_penalty: float = 0.0,
+        frequency_penalty: float = 0.0,
+        reply_count: int = 1,
+        truncate_limit: int = None,
+        use_plugins: bool = True,
+        print_log: bool = False,
+    ) -> None:
+        self.api_key: str = api_key
+        self.engine: str = engine
+        self.api_url: str = BaseAPI(api_url or "https://api.openai.com/v1/chat/completions")
+        self.system_prompt: str = system_prompt
+        self.max_tokens: int = max_tokens
+        self.truncate_limit: int = truncate_limit
+        self.temperature: float = temperature
+        self.top_p: float = top_p
+        self.presence_penalty: float = presence_penalty
+        self.frequency_penalty: float = frequency_penalty
+        self.reply_count: int = reply_count
+        self.truncate_limit: int = truncate_limit or (
+            198000
+            if "claude" in engine
+            else 1000000
+            if "gemini" in engine or "quasar-alpha" in engine
+            else 127500
+        )
+        self.timeout: float = timeout
+        self.proxy = proxy
+        self.session = requests.Session()
+        self.session.proxies.update(
+            {
+                "http": proxy,
+                "https": proxy,
+            },
+        )
+        if proxy := (
+            proxy or os.environ.get("all_proxy") or os.environ.get("ALL_PROXY") or None
+        ):
+            if "socks5h" not in proxy:
+                self.aclient = httpx.AsyncClient(
+                    follow_redirects=True,
+                    proxies=proxy,
+                    timeout=timeout,
+                )
+        else:
+            self.aclient = httpx.AsyncClient(
+                follow_redirects=True,
+                timeout=timeout,
+            )
+
+        self.conversation: dict[str, list[dict]] = {
+            "default": [
+                {
+                    "role": "system",
+                    "content": system_prompt,
+                },
+            ],
+        }
+        self.tokens_usage = defaultdict(int)
+        self.current_tokens = defaultdict(int)
+        self.function_calls_counter = {}
+        self.function_call_max_loop = 10
+        self.use_plugins = use_plugins
+        self.print_log: bool = print_log
+
+    def add_to_conversation(
+        self,
+        message: list,
+        role: str,
+        convo_id: str = "default",
+        function_name: str = "",
+    ) -> None:
+        """
+        Add a message to the conversation
+        """
+        pass
+
+    def __truncate_conversation(self, convo_id: str = "default") -> None:
+        """
+        Truncate the conversation
+        """
+        pass
+
+    def truncate_conversation(
+        self,
+        prompt: str,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        **kwargs,
+    ) -> None:
+        """
+        Truncate the conversation
+        """
+        pass
+
+    def extract_values(self, obj):
+        pass
+
+    def get_token_count(self, convo_id: str = "default") -> int:
+        """
+        Get token count
+        """
+        pass
+
+    def get_message_token(self, url, json_post):
+        pass
+
+    def get_post_body(
+        self,
+        prompt: str,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        **kwargs,
+    ):
+        pass
+
+    def get_max_tokens(self, convo_id: str) -> int:
+        """
+        Get max tokens
+        """
+        pass
+
+    def ask_stream(
+        self,
+        prompt: list,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        function_name: str = "",
+        **kwargs,
+    ):
+        """
+        Ask a question
+        """
+        pass
+
+    async def ask_stream_async(
+        self,
+        prompt: list,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        function_name: str = "",
+        **kwargs,
+    ):
+        """
+        Ask a question
+        """
+        pass
+
+    async def ask_async(
+        self,
+        prompt: str,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        **kwargs,
+    ) -> str:
+        """
+        Non-streaming ask
+        """
+        response = ""
+        async for chunk in self.ask_stream_async(
+            prompt=prompt,
+            role=role,
+            convo_id=convo_id,
+            model=model or self.engine,
+            pass_history=pass_history,
+            **kwargs,
+        ):
+            response += chunk
+        # full_response: str = "".join([r async for r in response])
+        full_response: str = "".join(response)
+        return full_response
+
+    def ask(
+        self,
+        prompt: str,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 0,
+        **kwargs,
+    ) -> str:
+        """
+        Non-streaming ask
+        """
+        response = self.ask_stream(
+            prompt=prompt,
+            role=role,
+            convo_id=convo_id,
+            model=model or self.engine,
+            pass_history=pass_history,
+            **kwargs,
+        )
+        full_response: str = "".join(response)
+        return full_response
+
+    def rollback(self, n: int = 1, convo_id: str = "default") -> None:
+        """
+        Rollback the conversation
+        """
+        for _ in range(n):
+            self.conversation[convo_id].pop()
+
+    def reset(self, convo_id: str = "default", system_prompt: str = None) -> None:
+        """
+        Reset the conversation
+        """
+        self.conversation[convo_id] = [
+            {"role": "system", "content": system_prompt or self.system_prompt},
+        ]
+
+    def save(self, file: str, *keys: str) -> None:
+        """
+        Save the Chatbot configuration to a JSON file
+        """
+        pass
+
+    def load(self, file: Path, *keys_: str) -> None:
+        """
+        Load the Chatbot configuration from a JSON file
+        """
+        pass