deepanything 0.1.4__tar.gz → 0.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.4
+Version: 0.1.6
 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.6}/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.6}/deepanything/Server/Server.py

@@ -1,3 +1,4 @@
+from chunk import Chunk
 from dataclasses import dataclass
 import time
 import uvicorn
@@ -5,9 +6,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.responses import StreamingResponse
+from fastapi import FastAPI,Depends, HTTPException, status,Header,Request
+from fastapi.responses import StreamingResponse,Response
 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 +37,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 +55,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 +69,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 +88,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 +142,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,13 +169,29 @@ 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):
+
+        async def _sse_warp(it: AsyncStream, req: Request):
             async for chunk in it:
-                yield f"data: {chunk.model_dump_json(indent=None)}\n\n"
-            yield "data: [DONE]"
+                if await req.is_disconnected():
+                    await it.close()
+                    break
+                yield f"data: {chunk.model_dump_json(indent=None)}\n\n".encode("utf-8")
+            yield "data: [DONE]".encode('utf-8')
 
         args = DeepAnythingServer._extract_args(query)
 
@@ -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,26 +213,30 @@ class DeepAnythingServer:
                     response_args=args,
                     reason_args=args,
                     max_tokens=max_tokens
-                )
+                ),
+                request
             )
             return StreamingResponse(
                 res,
-                media_type="text/event-stream"
+                media_type="text/event-stream",
             )
         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 Response(
+                content=res.model_dump_json(indent=None),
+                media_type="application/json"
             )
-            return res.model_dump_json()
 
     def get_models(self) -> Types.ModelsListResponse:
         return Types.ModelsListResponse(

{deepanything-0.1.4 → deepanything-0.1.6}/deepanything/__main__.py

@@ -1,11 +1,13 @@
 from deepanything.Server.Server import DeepAnythingServer
 import argparse
 import json
+from .metadatas import VERSION
 def main():
-    parser = argparse.ArgumentParser(prog="deepanything",description="Run a DeepAnything Server.")
+    parser = argparse.ArgumentParser(prog=f"deepanything {VERSION}",description="Run a DeepAnything Server.")
     parser.add_argument('--host', type=str, required=False, help='Specific the host to listen.If specified,the host will be overwritten by this.')
     parser.add_argument('--port', type=int, required=False, help='Specific the port to listen.If specified,the port will be overwritten by this.')
     parser.add_argument('--config', type=str, required=True, help='Specific the confi path.')
+    parser.add_argument('--version', action='version', version=f'%(prog)s {VERSION}')
 
     args = parser.parse_args()
 

deepanything-0.1.6/deepanything/metadatas.py

@@ -0,0 +1 @@
+VERSION = "v0.1.6"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.4
+Version: 0.1.6
 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.6}/deepanything.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ deepanything/Stream.py
 deepanything/Utility.py
 deepanything/__init__.py
 deepanything/__main__.py
+deepanything/metadatas.py
 deepanything.egg-info/PKG-INFO
 deepanything.egg-info/SOURCES.txt
 deepanything.egg-info/dependency_links.txt

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

@@ -1,4 +1,5 @@
 from setuptools import setup, find_packages
+from deepanything.metadatas import VERSION
 
 with open("README.md",encoding='utf-8') as f:
     long_description = f.read()
@@ -8,7 +9,7 @@ with open("requirements.txt") as f:
 
 setup(
     name="deepanything",
-    version="0.1.4",
+    version=VERSION,
     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.6}/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()