deepanything 0.1.4__tar.gz → 0.1.5__tar.gz

{deepanything-0.1.4 → deepanything-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.4
+Version: 0.1.5
 Summary: DeepAnything is a project that provides DeepSeek R1's deep thinking capabilities for various large language models (LLMs).
 Author: Junity
 Author-email: 1727636624@qq.com
@@ -159,6 +159,7 @@ More example can be find in [examples](examples).
 Below is an example of a configuration file:
 
 ```json
+// Using R1 with Qwen-Max-Latest
 {
   "host" : "0.0.0.0",
   "port" : 8080,
@@ -187,9 +188,41 @@ Below is an example of a configuration file:
       "response_model" :  "qwen-max-latest"
     }
   ],
-  "api_keys": [
+  "api_keys" : [
     "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-  ]
+  ],
+  "log": {
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "default": {
+            "()": "uvicorn.logging.DefaultFormatter",
+            "fmt": "%(levelprefix)s %(message)s",
+            "use_colors": null
+        },
+        "access": {
+            "()": "uvicorn.logging.AccessFormatter",
+            "fmt": "%(levelprefix)s %(client_addr)s - \"%(request_line)s\" %(status_code)s"
+        }
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr"
+        },
+        "access": {
+            "formatter": "access",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout"
+        }
+    },
+    "loggers": {
+        "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": false},
+        "uvicorn.error": {"level": "INFO"},
+        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false}
+    }
+  }
 }
 ```
 
@@ -198,6 +231,26 @@ Below is an example of a configuration file:
 - reason_clients: Configuration for thinking models, currently supports deepseek and openai types. When the type is openai, deepanything directly uses the model's output as the thinking content, and it is recommended to use qwq-32b in this case.
 - response_clients: Configuration for response models, currently only supports the openai type.
 - api_keys: API keys for user authentication. When left blank or an empty list, the server does not use API keys for authentication.
+- log: Log configuration. If this item is not filled in, the default logging configuration of uvicorn will be used. For details, please refer to [uvicorn logging configuration](https://www.uvicorn.org/settings/#logging).
+
+## Deploying with Docker
+### 1. Pull the Image
+```bash
+docker pull junity233/deepanything:latest
+```
+
+### 2. Create config.json
+First, create a folder in your desired directory, and then create a file named `config.json` inside it. This folder will be mounted into the container:
+```bash
+mkdir deepanything-data               # You can replace this with another name
+vim deepanything-data/config.json     # Edit the configuration file, you can refer to examples/config.json
+```
+
+### 3. Run the Container
+```bash
+# Remember to modify the port mapping
+docker run -v ./deepanything-data:/data -p 8080:8080 junity233/deepanything:latest
+```
 
 ## License
 

{deepanything-0.1.4 → deepanything-0.1.5}/README.md

@@ -141,6 +141,7 @@ More example can be find in [examples](examples).
 Below is an example of a configuration file:
 
 ```json
+// Using R1 with Qwen-Max-Latest
 {
   "host" : "0.0.0.0",
   "port" : 8080,
@@ -169,9 +170,41 @@ Below is an example of a configuration file:
       "response_model" :  "qwen-max-latest"
     }
   ],
-  "api_keys": [
+  "api_keys" : [
     "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-  ]
+  ],
+  "log": {
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "default": {
+            "()": "uvicorn.logging.DefaultFormatter",
+            "fmt": "%(levelprefix)s %(message)s",
+            "use_colors": null
+        },
+        "access": {
+            "()": "uvicorn.logging.AccessFormatter",
+            "fmt": "%(levelprefix)s %(client_addr)s - \"%(request_line)s\" %(status_code)s"
+        }
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr"
+        },
+        "access": {
+            "formatter": "access",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout"
+        }
+    },
+    "loggers": {
+        "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": false},
+        "uvicorn.error": {"level": "INFO"},
+        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false}
+    }
+  }
 }
 ```
 
@@ -180,6 +213,26 @@ Below is an example of a configuration file:
 - reason_clients: Configuration for thinking models, currently supports deepseek and openai types. When the type is openai, deepanything directly uses the model's output as the thinking content, and it is recommended to use qwq-32b in this case.
 - response_clients: Configuration for response models, currently only supports the openai type.
 - api_keys: API keys for user authentication. When left blank or an empty list, the server does not use API keys for authentication.
+- log: Log configuration. If this item is not filled in, the default logging configuration of uvicorn will be used. For details, please refer to [uvicorn logging configuration](https://www.uvicorn.org/settings/#logging).
+
+## Deploying with Docker
+### 1. Pull the Image
+```bash
+docker pull junity233/deepanything:latest
+```
+
+### 2. Create config.json
+First, create a folder in your desired directory, and then create a file named `config.json` inside it. This folder will be mounted into the container:
+```bash
+mkdir deepanything-data               # You can replace this with another name
+vim deepanything-data/config.json     # Edit the configuration file, you can refer to examples/config.json
+```
+
+### 3. Run the Container
+```bash
+# Remember to modify the port mapping
+docker run -v ./deepanything-data:/data -p 8080:8080 junity233/deepanything:latest
+```
 
 ## License
 

{deepanything-0.1.4 → deepanything-0.1.5}/deepanything/Server/Server.py

@@ -5,9 +5,10 @@ from typing import Dict, List, Optional, Any
 import json
 
 from openai.types.model import Model as OpenaiModel
-from fastapi import FastAPI,Depends, HTTPException, status,Header
+from fastapi import FastAPI,Depends, HTTPException, status,Header,Request
 from fastapi.responses import StreamingResponse
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from uvicorn.config import LOGGING_CONFIG
 
 from deepanything.DeepAnythingClient import chat_completion_stream_async, chat_completion_async
 from deepanything.ResponseClient import AsyncOpenaiResponseClient,AsyncResponseClient
@@ -35,6 +36,7 @@ class DeepAnythingServer:
     model_owner : str = "deepanything"
     api_keys : List[str] = []
     security = HTTPBearer()
+    log_config : Dict[str,Any] = LOGGING_CONFIG
 
     def __init__(self, host:str = None, port:int = None, config : Any or str = None):
         if config is not None:
@@ -52,7 +54,7 @@ class DeepAnythingServer:
         self.app.add_api_route("/v1/chat/completions",self.chat_completions,methods=["POST"])
 
     def run(self):
-        uvicorn.run(self.app,host=self.host,port=self.port,log_level="trace")
+        uvicorn.run(self.app,host=self.host,port=self.port,log_config=self.log_config)
 
     @staticmethod
     def _extract_args(query : Types.ChatCompletionQuery) -> dict:
@@ -66,36 +68,18 @@ class DeepAnythingServer:
         self.port = config_object.get("port",8000)
         self.model_owner = config_object.get("model_owner","deepanything")
 
-        reason_clients:List[Dict] = config_object.get("reason_clients",[])
+        self._load_reason_clients(config_object)
+        self._load_response_clients(config_object)
+        self._load_models(config_object)
 
-        for client in reason_clients:
-            name = client["name"]
-            base_url = client["base_url"]
-            api_key = client.get("api_key","")
-            extract_args = client.get("extract_args",{})
-
-            if client["type"] == 'deepseek':
-                self.reason_clients[name] = AsyncDeepseekReasonClient(base_url, api_key, **extract_args)
-            elif client["type"] == 'openai':
-                self.reason_clients[name] = AsyncOpenaiReasonClient(base_url, api_key, **extract_args)
-            else:
-                raise Exception("unknown reason client type")
-
-        response_clients : List[Dict] = config_object.get("response_clients",[])
-
-        for client in response_clients:
-            name = client["name"]
-            base_url = client["base_url"]
-            api_key = client.get("api_key","")
-            extract_args = client.get("extract_args",{})
-
-            if client["type"] == 'openai':
-                self.response_clients[name] = AsyncOpenaiResponseClient(base_url,api_key,**extract_args)
-            else:
-                raise Exception("unknown response client type")
+        self.api_keys = config_object.get("api_keys",[])
+        self.log_config = config_object.get("log",LOGGING_CONFIG)
+        if self.log_config == {}:
+            self.log_config = LOGGING_CONFIG
 
-        models : List[Dict] = config_object.get("models",[])
 
+    def _load_models(self, config_object):
+        models: List[Dict] = config_object.get("models", [])
         for _model in models:
             name = _model["name"]
             reason_client = _model["reason_client"]
@@ -103,20 +87,51 @@ class DeepAnythingServer:
             response_client = _model["response_client"]
             response_model = _model["response_model"]
             created = _model.get("created", int(time.time()))
-            reason_prompt = _model.get("reason_prompt","<Think>{}</Think>")
+            reason_prompt = _model.get("reason_prompt", "<Think>{}</Think>")
+
+            if reason_client not in self.reason_clients:
+                raise ValueError(f"Reason client '{reason_model}' for '{name}' not found")
+
+            if response_client not in self.response_clients:
+                raise ValueError(f"Response client '{response_model}' for '{name}' not found")
 
             self.models[name] = ModelInfo(
-                name = name,
-                reason_client = reason_client,
-                reason_model = reason_model,
-                response_client = response_client,
-                response_model = response_model,
-                created = created,
-                reason_prompt = reason_prompt
+                name=name,
+                reason_client=reason_client,
+                reason_model=reason_model,
+                response_client=response_client,
+                response_model=response_model,
+                created=created,
+                reason_prompt=reason_prompt
             )
 
-        self.api_keys = config_object.get("api_keys",[])
+    def _load_response_clients(self, config_object):
+        response_clients: List[Dict] = config_object.get("response_clients", [])
+        for client in response_clients:
+            name = client["name"]
+            base_url = client["base_url"]
+            api_key = client.get("api_key", "")
+            extract_args = client.get("extract_args", {})
 
+            if client["type"] == 'openai':
+                self.response_clients[name] = AsyncOpenaiResponseClient(base_url, api_key, **extract_args)
+            else:
+                raise ValueError(f"Unsupported response client type '{client['type']}'")
+
+    def _load_reason_clients(self, config_object):
+        reason_clients: List[Dict] = config_object.get("reason_clients", [])
+        for client in reason_clients:
+            name = client["name"]
+            base_url = client["base_url"]
+            api_key = client.get("api_key", "")
+            extract_args = client.get("extract_args", {})
+
+            if client["type"] == 'deepseek':
+                self.reason_clients[name] = AsyncDeepseekReasonClient(base_url, api_key, **extract_args)
+            elif client["type"] == 'openai':
+                self.reason_clients[name] = AsyncOpenaiReasonClient(base_url, api_key, **extract_args)
+            else:
+                raise Exception("unknown reason client type")
 
     def add_reason_client(self,name:str,client:AsyncReasonClient):
         self.reason_clients[name] = client
@@ -126,7 +141,8 @@ class DeepAnythingServer:
 
     def add_model(self,name:str,model:ModelInfo):
         self.models[name] = model
-    def verify_authorization(self, authorization:Optional[str]):
+
+    def _verify_authorization(self, authorization:Optional[str]):
         if not self.api_keys:
             return
 
@@ -152,11 +168,28 @@ class DeepAnythingServer:
                 headers={"WWW-Authenticate": "Bearer"},
             )
 
-    async def chat_completions(self, query : Types.ChatCompletionQuery, authorization:Optional[str] = Header(None)):
-        self.verify_authorization(authorization)
+    async def chat_completions(
+            self,
+            request: Request,  # 新增加Request参数
+            query: Types.ChatCompletionQuery,
+            authorization: Optional[str] = Header(None)
+    ):
+        self._verify_authorization(authorization)
+
+        if query.model not in self.models:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Model not found",
+            )
+
         model = self.models[query.model]
-        async def sse(it: AsyncStream):
+
+        # 修改点1：将request传递给_sse_warp生成器
+        async def _sse_warp(it: AsyncStream, req: Request):
             async for chunk in it:
+                if await req.is_disconnected():
+                    await it.close()
+                    break
                 yield f"data: {chunk.model_dump_json(indent=None)}\n\n"
             yield "data: [DONE]"
 
@@ -168,7 +201,7 @@ class DeepAnythingServer:
             args.pop("max_tokens")
 
         if query.stream:
-            res = sse(
+            res = _sse_warp(
                 await chat_completion_stream_async(
                     messages=query.messages,
                     reason_client=self.reason_clients[model.reason_client],
@@ -180,7 +213,8 @@ class DeepAnythingServer:
                     response_args=args,
                     reason_args=args,
                     max_tokens=max_tokens
-                )
+                ),
+                request  # 传入request对象
             )
             return StreamingResponse(
                 res,
@@ -188,16 +222,16 @@ class DeepAnythingServer:
             )
         else:
             res = await chat_completion_async(
-                    messages=query.messages,
-                    reason_client=self.reason_clients[model.reason_client],
-                    reason_model=model.reason_model,
-                    response_client=self.response_clients[model.response_client],
-                    response_model=model.response_model,
-                    show_model=model.name,
-                    reason_prompt=model.reason_prompt,
-                    response_args=args,
-                    reason_args=args,
-                    max_tokens=max_tokens
+                messages=query.messages,
+                reason_client=self.reason_clients[model.reason_client],
+                reason_model=model.reason_model,
+                response_client=self.response_clients[model.response_client],
+                response_model=model.response_model,
+                show_model=model.name,
+                reason_prompt=model.reason_prompt,
+                response_args=args,
+                reason_args=args,
+                max_tokens=max_tokens
             )
             return res.model_dump_json()
 

{deepanything-0.1.4 → deepanything-0.1.5}/deepanything.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.4
+Version: 0.1.5
 Summary: DeepAnything is a project that provides DeepSeek R1's deep thinking capabilities for various large language models (LLMs).
 Author: Junity
 Author-email: 1727636624@qq.com
@@ -159,6 +159,7 @@ More example can be find in [examples](examples).
 Below is an example of a configuration file:
 
 ```json
+// Using R1 with Qwen-Max-Latest
 {
   "host" : "0.0.0.0",
   "port" : 8080,
@@ -187,9 +188,41 @@ Below is an example of a configuration file:
       "response_model" :  "qwen-max-latest"
     }
   ],
-  "api_keys": [
+  "api_keys" : [
     "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-  ]
+  ],
+  "log": {
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "default": {
+            "()": "uvicorn.logging.DefaultFormatter",
+            "fmt": "%(levelprefix)s %(message)s",
+            "use_colors": null
+        },
+        "access": {
+            "()": "uvicorn.logging.AccessFormatter",
+            "fmt": "%(levelprefix)s %(client_addr)s - \"%(request_line)s\" %(status_code)s"
+        }
+    },
+    "handlers": {
+        "default": {
+            "formatter": "default",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr"
+        },
+        "access": {
+            "formatter": "access",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout"
+        }
+    },
+    "loggers": {
+        "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": false},
+        "uvicorn.error": {"level": "INFO"},
+        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false}
+    }
+  }
 }
 ```
 
@@ -198,6 +231,26 @@ Below is an example of a configuration file:
 - reason_clients: Configuration for thinking models, currently supports deepseek and openai types. When the type is openai, deepanything directly uses the model's output as the thinking content, and it is recommended to use qwq-32b in this case.
 - response_clients: Configuration for response models, currently only supports the openai type.
 - api_keys: API keys for user authentication. When left blank or an empty list, the server does not use API keys for authentication.
+- log: Log configuration. If this item is not filled in, the default logging configuration of uvicorn will be used. For details, please refer to [uvicorn logging configuration](https://www.uvicorn.org/settings/#logging).
+
+## Deploying with Docker
+### 1. Pull the Image
+```bash
+docker pull junity233/deepanything:latest
+```
+
+### 2. Create config.json
+First, create a folder in your desired directory, and then create a file named `config.json` inside it. This folder will be mounted into the container:
+```bash
+mkdir deepanything-data               # You can replace this with another name
+vim deepanything-data/config.json     # Edit the configuration file, you can refer to examples/config.json
+```
+
+### 3. Run the Container
+```bash
+# Remember to modify the port mapping
+docker run -v ./deepanything-data:/data -p 8080:8080 junity233/deepanything:latest
+```
 
 ## License
 

{deepanything-0.1.4 → deepanything-0.1.5}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt") as f:
 
 setup(
     name="deepanything",
-    version="0.1.4",
+    version="0.1.5",
     author="Junity",
     author_email="1727636624@qq.com",
     description="DeepAnything is a project that provides DeepSeek R1's deep thinking capabilities for various large language models (LLMs).",

{deepanything-0.1.4 → deepanything-0.1.5}/test/think.py

@@ -20,7 +20,21 @@ da_client = DeepAnythingClient(
     reason_prompt="<Think>{}</Think>"
 )
 def main():
-    stream = da_client.chat_completion_stream(
+    # stream = da_client.chat_completion_stream(
+    #     messages=[
+    #         {
+    #             "role": "user",
+    #             "content": "你好"
+    #         }
+    #     ],
+    #     reason_model="Pro/deepseek-ai/DeepSeek-R1",
+    #     response_model="qwen-max-latest",
+    #     show_model="R1-qwen-max"
+    # )
+    #
+    # for chunk in stream:
+    #     print(chunk)
+    res = da_client.chat_completion(
         messages=[
             {
                 "role": "user",
@@ -32,8 +46,6 @@ def main():
         show_model="R1-qwen-max"
     )
 
-    for chunk in stream:
-        print(chunk)
-
+    print(res)
 
 main()