SimpleLLMFunc 0.2.0__tar.gz → 0.2.3__tar.gz

{simplellmfunc-0.2.0 → simplellmfunc-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: SimpleLLMFunc
-Version: 0.2.0
+Version: 0.2.3
 Summary: 一个轻量但完备的LLM/Agent应用开发框架，提供装饰器实现将函数DocString作为Prompt而无需函数体具体实现但能够享受函数定义和类型标注带来效率提升的开发体验。以最Code的方式，用最少的代码将LLM能力集成到任意Python项目中。
 Author: Ni Jingzhe
 Author-email: nijingzhe@zjue.edu.cn
@@ -15,10 +15,10 @@ Requires-Dist: openai (>=1.84.0,<2.0.0)
 Requires-Dist: pydantic (>=2.11.5,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.9.1,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: rich (>=14.0.0,<15.0.0)
 Description-Content-Type: text/markdown
 
-
-![SimpleLLMFunc](https://github.com/NiJingzhe/SimpleLLMFunc/blob/master/img/repocover.png?raw=true)
+![SimpleLLMFunc](https://github.com/NiJingzhe/SimpleLLMFunc/blob/master/img/repocover_new.png?raw=true)
 
 <center>
 <h2 style="font-size:2em;">Everything is Function, Prompt is Code</h2>
@@ -480,7 +480,7 @@ pip install SimpleLLMFunc
   month = {June},
   title = {{SimpleLLMFunc: A New Approach to Build LLM Applications}},
   url = {https://github.com/NiJingzhe/SimpleLLMFunc},
-  version = {0.2.0},
+  version = {0.2.1},
   year = {2025}
 }
 ```

{simplellmfunc-0.2.0 → simplellmfunc-0.2.3}/README.md

@@ -1,5 +1,4 @@
-
-![SimpleLLMFunc](https://github.com/NiJingzhe/SimpleLLMFunc/blob/master/img/repocover.png?raw=true)
+![SimpleLLMFunc](https://github.com/NiJingzhe/SimpleLLMFunc/blob/master/img/repocover_new.png?raw=true)
 
 <center>
 <h2 style="font-size:2em;">Everything is Function, Prompt is Code</h2>
@@ -461,7 +460,7 @@ pip install SimpleLLMFunc
   month = {June},
   title = {{SimpleLLMFunc: A New Approach to Build LLM Applications}},
   url = {https://github.com/NiJingzhe/SimpleLLMFunc},
-  version = {0.2.0},
+  version = {0.2.1},
   year = {2025}
 }
 ```

{simplellmfunc-0.2.0 → simplellmfunc-0.2.3}/SimpleLLMFunc/interface/llm_interface.py

@@ -1,19 +1,22 @@
 from abc import ABC, abstractmethod
-from typing import Generator, Union, Optional, Dict, List, Iterable, Literal, Any
+from typing import Optional, Dict, Iterable, Literal, Any, AsyncGenerator
 
 from SimpleLLMFunc.interface.key_pool import APIKeyPool
 from SimpleLLMFunc.logger import get_current_trace_id
 
+
 class LLM_Interface(ABC):
-    
+
     @abstractmethod
-    def __init__(self, api_key_pool: APIKeyPool, model_name: str, base_url: Optional[str] = None):
+    def __init__(
+        self, api_key_pool: APIKeyPool, model_name: str, base_url: Optional[str] = None
+    ):
         self.input_token_count = 0
         self.output_token_count = 0
-    
+
     @abstractmethod
-    def chat(
-        self, 
+    async def chat(
+        self,
         trace_id: str = get_current_trace_id(),
         stream: Literal[False] = False,
         messages: Iterable[Dict[str, str]] = [{"role": "user", "content": ""}],
@@ -22,15 +25,17 @@ class LLM_Interface(ABC):
         **kwargs,
     ) -> Dict[Any, Any]:
         pass
-    
+
     @abstractmethod
-    def chat_stream(
-        self, 
+    async def chat_stream(
+        self,
         trace_id: str = get_current_trace_id(),
         stream: Literal[True] = True,
         messages: Iterable[Dict[str, str]] = [{"role": "user", "content": ""}],
         timeout: Optional[int] = None,
         *args,
         **kwargs,
-    ) -> Generator[Dict[Any, Any], None, None]:
-        pass
+    ) -> AsyncGenerator[Dict[Any, Any], None]:
+        # 空的异步生成器，永远不会产生任何值
+        if False:
+            yield {}

{simplellmfunc-0.2.0 → simplellmfunc-0.2.3}/SimpleLLMFunc/interface/openai_compatible.py

@@ -2,13 +2,25 @@ from __future__ import annotations
 import json
 import os
 import time
-from typing import Generator, Optional, Dict, List, Literal, Iterable, Any
+from typing import Optional, Dict, Literal, Iterable, Any, AsyncGenerator
 
-from openai import OpenAI, AsyncOpenAI
+from openai import AsyncOpenAI
 from SimpleLLMFunc.interface.llm_interface import LLM_Interface
 from SimpleLLMFunc.interface.key_pool import APIKeyPool
-from SimpleLLMFunc.logger import app_log, push_warning, push_error, get_location, get_current_trace_id
-from SimpleLLMFunc.logger.logger import push_critical, get_current_context_attribute, set_current_context_attribute
+from SimpleLLMFunc.logger import (
+    app_log,
+    push_warning,
+    push_error,
+    get_location,
+    get_current_trace_id,
+    push_debug,
+)
+from SimpleLLMFunc.logger.logger import (
+    push_critical,
+    get_current_context_attribute,
+    set_current_context_attribute,
+)
+
 
 class OpenAICompatible(LLM_Interface):
     """与OpenAI API兼容的LLM接口实现，支持任何符合OpenAI格式的API接口。
@@ -19,10 +31,10 @@ class OpenAICompatible(LLM_Interface):
 
     def _count_tokens(self, response: Any) -> tuple[int, int]:
         """计算响应中的token数量
-        
+
         Args:
             response: OpenAI API的响应对象
-            
+
         Returns:
             (输入token数, 输出token数)的元组
         """
@@ -35,12 +47,14 @@ class OpenAICompatible(LLM_Interface):
             return 0, 0
 
     @classmethod
-    def load_from_json_file(cls, json_path: str) -> Dict[str, Dict[str, OpenAICompatible]]:
+    def load_from_json_file(
+        cls, json_path: str
+    ) -> Dict[str, Dict[str, OpenAICompatible]]:
         """从JSON字符串加载OpenAICompatible实例
 
         Args:
             json_str: JSON字符串，包含API密钥和模型名称
-            
+
             例如:
             ```
             {
@@ -75,25 +89,28 @@ class OpenAICompatible(LLM_Interface):
                         "max_retries": 5,
                         "retry_delay": 1.0
                     }
-                ]    
+                ]
             }
             ```
 
         Returns:
-            OpenAICompatible实例的字典, 可以这样访问： 
+            OpenAICompatible实例的字典, 可以这样访问：
             ```python
             from SimpleLLMFunc.interface.openai_compatible import OpenAICompatible
 
             all_models = OpenAICompatible.load_from_json(json_str)
             gpt_3_5 = all_models["openai"]["gpt-3.5-turbo"]
             gpt_4 = all_models["openai"]["gpt-4"]
-            ``` 
+            ```
         """
-        
+
         if not os.path.exists(json_path):
-            push_critical(f"JSON 文件 {json_path} 不存在。请检查您的配置。", location=get_location())
+            push_critical(
+                f"JSON 文件 {json_path} 不存在。请检查您的配置。",
+                location=get_location(),
+            )
             raise FileNotFoundError(f"JSON 文件 {json_path} 不存在。")
-        
+
         with open(json_path, "r", encoding="utf-8") as f:
             json_str = f.read()
         # 解析JSON字符串
@@ -103,20 +120,25 @@ class OpenAICompatible(LLM_Interface):
             push_critical(f"解析 JSON 字符串失败：{e}", location=get_location())
             raise ValueError(f"解析 JSON 字符串失败：{e}")
         # 检查JSON格式
-        
-        try: 
+
+        try:
             all_providers_dict: Dict[str, Dict[str, OpenAICompatible]] = {}
             for provider_id, models in all_providers_info.items():
                 all_providers_dict[provider_id] = {}
                 app_log(
                     f"正在为提供商加载 OpenAICompatible 实例：{provider_id}",
-                    location=get_location()
+                    location=get_location(),
                 )
-                
+
                 if not isinstance(models, list):
-                    push_critical(f"提供商 {provider_id} 下的模型格式无效。应为列表。", location=get_location())
-                    raise TypeError(f"提供商 {provider_id} 下的模型格式无效。应为列表。")
-                
+                    push_critical(
+                        f"提供商 {provider_id} 下的模型格式无效。应为列表。",
+                        location=get_location(),
+                    )
+                    raise TypeError(
+                        f"提供商 {provider_id} 下的模型格式无效。应为列表。"
+                    )
+
                 for model_info in models:
                     model_name = model_info["model_name"]
                     api_keys = model_info["api_keys"]
@@ -137,13 +159,15 @@ class OpenAICompatible(LLM_Interface):
                     )
 
                     all_providers_dict[provider_id][model_name] = instance
-                    
+
                     app_log(
                         f"已为提供商 {provider_id} 加载模型 {model_name} 的 OpenAICompatible 实例",
-                        location=get_location()
+                        location=get_location(),
                     )
         except ValueError as e:
-            push_critical(f"加载 OpenAICompatible 实例时出错：{e}", location=get_location())
+            push_critical(
+                f"加载 OpenAICompatible 实例时出错：{e}", location=get_location()
+            )
             raise ValueError(f"加载 OpenAICompatible 实例时出错：{e}")
         except TypeError as e:
             push_critical(f"JSON 中的类型无效：{e}", location=get_location())
@@ -152,14 +176,19 @@ class OpenAICompatible(LLM_Interface):
             push_critical(f"JSON 中缺少必需的密钥：{e}", location=get_location())
             raise ValueError(f"JSON 中缺少必需的密钥：{e}")
         except Exception as e:
-            push_critical(f"加载 OpenAICompatible 实例时发生未知错误：{e}", location=get_location())
+            push_critical(
+                f"加载 OpenAICompatible 实例时发生未知错误：{e}",
+                location=get_location(),
+            )
             raise ValueError(f"加载 OpenAICompatible 实例时发生未知错误：{e}")
-        
+
         return all_providers_dict
 
     def __repr__(self) -> str:
         """返回OpenAICompatible实例的字符串表示"""
-        return f"OpenAICompatible(model_name={self.model_name}, base_url={self.base_url})"
+        return (
+            f"OpenAICompatible(model_name={self.model_name}, base_url={self.base_url})"
+        )
 
     def __init__(
         self,
@@ -186,13 +215,20 @@ class OpenAICompatible(LLM_Interface):
         self.model_name = model_name
 
         self.key_pool = api_key_pool
-        self.client = OpenAI(api_key=api_key_pool.get_least_loaded_key(), base_url=self.base_url)
+        self.client = AsyncOpenAI(
+            api_key=api_key_pool.get_least_loaded_key(), base_url=self.base_url
+        )
 
-    def chat(
+    async def chat(
         self,
         trace_id: str = get_current_trace_id(),
         stream: Literal[False] = False,
-        messages: Iterable[Dict[str, str]] = [{"role": "system", "content": "你是一位乐于助人的助手，可以帮助用户解决各种问题。"}],
+        messages: Iterable[Dict[str, str]] = [
+            {
+                "role": "system",
+                "content": "你是一位乐于助人的助手，可以帮助用户解决各种问题。",
+            }
+        ],
         timeout: Optional[int] = 30,
         *args,
         **kwargs,
@@ -210,19 +246,19 @@ class OpenAICompatible(LLM_Interface):
             LLM的响应内容
         """
         key = self.key_pool.get_least_loaded_key()
-        self.client = OpenAI(api_key=key, base_url=self.base_url)
-        
+        self.client = AsyncOpenAI(api_key=key, base_url=self.base_url)
+
         attempt = 0
         while attempt < self.max_retries:
             try:
                 self.key_pool.increment_task_count(key)
                 data = json.dumps(messages, ensure_ascii=False, indent=4)
-                app_log(
+                push_debug(
                     f"OpenAICompatible::chat: {self.model_name} request with API key: {key}, and message: {data}",
-                    location=get_location()
+                    location=get_location(),
                 )
-                response: Dict[Any, Any] = self.client.chat.completions.create(  # type: ignore
-                    messages=messages,   # type: ignore
+                response: Dict[Any, Any] = await self.client.chat.completions.create(  # type: ignore
+                    messages=messages,  # type: ignore
                     model=self.model_name,
                     stream=stream,
                     timeout=timeout,
@@ -233,17 +269,21 @@ class OpenAICompatible(LLM_Interface):
                 # 统计token
                 if not (response.choices and response.choices[0].message and response.choices[0].message.tool_calls):  # type: ignore
                     prompt_tokens, completion_tokens = self._count_tokens(response)
-                    
+
                     # 更新上下文中的token计数
                     input_tokens = get_current_context_attribute("input_tokens") or 0
                     output_tokens = get_current_context_attribute("output_tokens") or 0
-                    
-                    set_current_context_attribute("input_tokens", input_tokens + prompt_tokens)
-                    set_current_context_attribute("output_tokens", output_tokens + completion_tokens)
-                
+
+                    set_current_context_attribute(
+                        "input_tokens", input_tokens + prompt_tokens
+                    )
+                    set_current_context_attribute(
+                        "output_tokens", output_tokens + completion_tokens
+                    )
+
                 self.key_pool.decrement_task_count(key)
                 return response  # 请求成功，返回结果
-            
+
             except Exception as e:
                 self.key_pool.decrement_task_count(key)
                 attempt += 1
@@ -255,7 +295,7 @@ class OpenAICompatible(LLM_Interface):
                 )
 
                 key = self.key_pool.get_least_loaded_key()
-                self.client = OpenAI(api_key=key, base_url=self.base_url)
+                self.client = AsyncOpenAI(api_key=key, base_url=self.base_url)
 
                 if attempt >= self.max_retries:
                     push_error(
@@ -266,15 +306,20 @@ class OpenAICompatible(LLM_Interface):
                 time.sleep(self.retry_delay)  # 重试前等待一段时间
         return {}  # 添加默认返回以满足类型检查，实际上这行代码永远不会执行
 
-    def chat_stream(
+    async def chat_stream(
         self,
         trace_id: str = get_current_trace_id(),
         stream: Literal[True] = True,
-        messages: Iterable[Dict[str, str]] = [{"role": "system", "content": "你是一位乐于助人的助手，可以帮助用户解决各种问题。"}],
+        messages: Iterable[Dict[str, str]] = [
+            {
+                "role": "system",
+                "content": "你是一位乐于助人的助手，可以帮助用户解决各种问题。",
+            }
+        ],
         timeout: Optional[int] = 30,
         *args,
         **kwargs,
-    ) -> Generator[Dict[Any, Any], None, None]:
+    ) -> AsyncGenerator[Dict[Any, Any], None]:
         """执行流式LLM对话请求
 
         Args:
@@ -288,18 +333,18 @@ class OpenAICompatible(LLM_Interface):
             LLM的响应块
         """
         key = self.key_pool.get_least_loaded_key()
-        self.client = OpenAI(api_key=key, base_url=self.base_url)
+        self.client = AsyncOpenAI(api_key=key, base_url=self.base_url)
 
         attempt = 0
         while attempt < self.max_retries:
             try:
                 self.key_pool.increment_task_count(key)
                 data = json.dumps(messages, ensure_ascii=False, indent=4)
-                app_log(
+                push_debug(
                     f"OpenAICompatible::chat_stream: {self.model_name} request with API key: {key}, and message: {data}",
-                    location=get_location()
+                    location=get_location(),
                 )
-                response: Generator[Dict[Any, Any], None, None] = self.client.chat.completions.create(  # type: ignore
+                response = await self.client.chat.completions.create(  # type: ignore
                     messages=messages,  # type: ignore
                     model=self.model_name,
                     stream=stream,
@@ -311,7 +356,7 @@ class OpenAICompatible(LLM_Interface):
                 total_prompt_tokens = 0
                 total_completion_tokens = 0
 
-                for chunk in response:
+                async for chunk in response:
                     yield chunk  # 按块返回生成器中的数据
                     if chunk.choices and chunk.choices[0].delta:  # type: ignore
                         if not chunk.choices[0].delta.tool_calls:  # type: ignore
@@ -323,8 +368,12 @@ class OpenAICompatible(LLM_Interface):
                 input_tokens = get_current_context_attribute("input_tokens") or 0
                 output_tokens = get_current_context_attribute("output_tokens") or 0
 
-                set_current_context_attribute("input_tokens", input_tokens + total_prompt_tokens)
-                set_current_context_attribute("output_tokens", output_tokens + total_completion_tokens)
+                set_current_context_attribute(
+                    "input_tokens", input_tokens + total_prompt_tokens
+                )
+                set_current_context_attribute(
+                    "output_tokens", output_tokens + total_completion_tokens
+                )
 
                 self.key_pool.decrement_task_count(key)
                 break  # 如果成功，跳出重试循环
@@ -335,20 +384,21 @@ class OpenAICompatible(LLM_Interface):
                 data = json.dumps(messages, ensure_ascii=False, indent=4)
                 push_warning(
                     f"{self.model_name} Interface attempt {attempt} failed: With message : {data} send, \n but exception : {str(e)} was caught",
-                    location=get_location()
+                    location=get_location(),
                 )
 
                 key = self.key_pool.get_least_loaded_key()
-                self.client = OpenAI(api_key=key, base_url=self.base_url)
+                self.client = AsyncOpenAI(api_key=key, base_url=self.base_url)
 
                 if attempt >= self.max_retries:
                     push_error(
                         f"Max retries reached. {self.model_name} Failed to get a response for {data}",
-                        location=get_location()
+                        location=get_location(),
                     )
                     raise e
                 time.sleep(self.retry_delay)
-        
+
         # 下面是一个空生成器，用于满足类型检查，实际上永远不会执行到这里
         if False:
-            yield {}
+            yield {}
+

{simplellmfunc-0.2.0 → simplellmfunc-0.2.3}/SimpleLLMFunc/llm_decorator/__init__.py

@@ -1,6 +1,8 @@
-from SimpleLLMFunc.llm_decorator.llm_function_decorator import llm_function
-from SimpleLLMFunc.llm_decorator.llm_chat_decorator import llm_chat
+from SimpleLLMFunc.llm_decorator.llm_function_decorator import llm_function, async_llm_function
+from SimpleLLMFunc.llm_decorator.llm_chat_decorator import llm_chat, async_llm_chat
 __all__ = [
     "llm_function",
-    "llm_chat"
+    "async_llm_function",
+    "llm_chat",
+    "async_llm_chat"
 ]