deepanything 0.1.6__tar.gz → 0.1.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.6
+Version: 0.1.7
 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

{deepanything-0.1.6 → deepanything-0.1.7}/deepanything/DeepAnythingClient.py

@@ -4,7 +4,8 @@ from openai.types.chat.chat_completion import ChatCompletion
 
 from deepanything.Stream import Stream,AsyncStream
 from deepanything.Utility import make_usage, make_chat_completion_message, merge_chunk, async_merge_chunk, \
-    make_chat_completion_chunk, make_chat_completion, make_chat_completion_choice, merge_usage, make_id_by_timestamp
+    make_chat_completion_chunk, make_chat_completion, make_chat_completion_choice, merge_usage, make_id_by_timestamp, \
+    attend_message
 from deepanything.ResponseClient import ResponseClient,AsyncResponseClient
 from deepanything.ReasonClient import ReasonClient,AsyncReasonClient
 
@@ -41,10 +42,7 @@ def _build_message(
         reason_content : str,
         reason_prompt : str
 ) -> List:
-    return messages + [make_chat_completion_message(
-        role="assistant",
-        content=reason_prompt.format(reason_content)
-    )]
+    return attend_message(messages,role="assistant",content=reason_prompt.format(reason_content))
 def _process_reason_chunk(chunk, reasoning_contents, reason_usage, show_model, created, _id):
     new_chunk = chunk.model_copy(deep=False)
     new_chunk.model = show_model
@@ -83,6 +81,7 @@ def chat_completion(
         reason_args=None,
         response_args=None,
         reason_prompt: str = "<Think>{}</Think>",
+        reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         stream = False,
         _id: str = make_id_by_timestamp(),
@@ -105,7 +104,8 @@ def chat_completion(
             created=created,
             _id=_id,
             reason_prompt=reason_prompt,
-            max_tokens=max_tokens
+            reason_system_prompt=reason_system_prompt,
+            max_tokens=max_tokens,
         )
 
     if max_tokens is not None:
@@ -145,6 +145,7 @@ def chat_completion_stream(
         reason_args=None,
         response_args=None,
         reason_prompt: str = "<Think>{}</Think>",
+        reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         _id: str = make_id_by_timestamp(),
         max_tokens : Optional[int] = None
@@ -166,6 +167,7 @@ def chat_completion_stream(
         reason_stream = reason_client.reason_stream(
             messages,
             reason_model,
+            reason_system_prompt,
             **reason_args
         )
         stream = reason_stream
@@ -206,6 +208,7 @@ async def chat_completion_async(
         reason_args=None,
         response_args=None,
         reason_prompt: str = "<Think>{}</Think>",
+        reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         _id: str = make_id_by_timestamp(),
         stream=False,
@@ -228,6 +231,7 @@ async def chat_completion_async(
             created=created,
             _id=_id,
             reason_prompt=reason_prompt,
+            reason_system_prompt=reason_system_prompt,
             max_tokens=max_tokens
         )
 
@@ -246,11 +250,14 @@ async def chat_completion_async(
             return reason_chat_completion
         response_args["max_tokens"] = max_tokens
 
+    messages = _build_message(
+        messages,
+        reason_chat_completion.choices[0].message.reasoning_content,
+        reason_prompt
+    )
+
     response_chat_completion:ChatCompletion = await response_client.chat_completions(
-        messages=messages + [make_chat_completion_message(
-            role="assistant",
-            content=reason_prompt.format(reason_chat_completion.choices[0].message.reasoning_content)
-        )],
+        messages=messages,
         model=response_model,
         **response_args
     )
@@ -267,6 +274,7 @@ async def chat_completion_stream_async(
         reason_args=None,
         response_args=None,
         reason_prompt: str = "<Think>{}</Think>",
+        reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         _id: str = make_id_by_timestamp(),
         max_tokens : Optional[int] = None
@@ -287,6 +295,7 @@ async def chat_completion_stream_async(
         reason_stream = await reason_client.reason_stream(
             messages,
             reason_model,
+            reason_system_prompt,
             **reason_args
         )
 
@@ -342,6 +351,7 @@ class DeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
             _id : str = make_id_by_timestamp(),
             stream = False
@@ -355,6 +365,7 @@ class DeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             stream=stream,
@@ -369,6 +380,7 @@ class DeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
             _id : str = make_id_by_timestamp()
     ) -> Stream:
@@ -381,6 +393,7 @@ class DeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             reason_prompt=self.reason_prompt
@@ -411,6 +424,7 @@ class AsyncDeepAnythingClient:
             show_model: str,
             reason_args=None,
             response_args=None,
+            reason_system_prompt: Optional[str] = None,
             created: int = int(time.time()),
             _id: str = make_id_by_timestamp(),
             stream=False
@@ -424,6 +438,7 @@ class AsyncDeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             stream=stream,
@@ -438,6 +453,7 @@ class AsyncDeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
             _id : str = make_id_by_timestamp()
     ) -> AsyncStream:
@@ -450,6 +466,7 @@ class AsyncDeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             reason_prompt=self.reason_prompt

{deepanything-0.1.6 → deepanything-0.1.7}/deepanything/ReasonClient.py

@@ -1,4 +1,7 @@
+from typing import Optional
+
 import openai
+from openai import OpenAI
 from openai.types.chat import chat_completion, chat_completion_chunk
 from deepanything.Stream import Stream,AsyncStream
 from deepanything import Utility
@@ -12,6 +15,7 @@ class ReasonClient:
             self,
             messages:list[dict],
             model:str,
+            reason_system_prompt:Optional[str] = None,
             stream = False,
             **kwargs
     ) -> Stream or chat_completion.ChatCompletion:
@@ -26,6 +30,7 @@ class ReasonClient:
     def reason_stream(self,
                       messages:list[dict],
                       model:str,
+                      reason_system_prompt:Optional[str] = None,
                       **kwargs
                       ) -> Stream:
         raise NotImplementedError
@@ -38,6 +43,7 @@ class AsyncReasonClient:
             self,
             messages:list[dict],
             model:str,
+            reason_system_prompt:Optional[str] = None,
             stream = False,
             **kwargs
     ) -> AsyncStream or chat_completion.ChatCompletion:
@@ -52,6 +58,7 @@ class AsyncReasonClient:
     async def reason_stream(self,
                             messages:list[dict],
                             model:str,
+                            reason_system_prompt:Optional[str] = None,
                             **kwargs
                             ) -> AsyncStream:
         raise NotImplementedError
@@ -70,6 +77,7 @@ class DeepseekReasonClient(ReasonClient):
     def reason_stream(self,
                       messages: list[dict],
                       model: str,
+                      reason_system_prompt:Optional[str] = None, # not used
                       **kwargs
                       ) -> Stream:
         stream = self.client.chat.completions.create(
@@ -108,6 +116,7 @@ class AsyncDeepseekReasonClient(AsyncReasonClient):
     async def reason_stream(self,
                             messages: list[dict],
                             model: str,
+                            reason_system_prompt:Optional[str] = None,
                             **kwargs
                             ) -> AsyncStream:
         stream = await self.client.chat.completions.create(
@@ -161,8 +170,12 @@ class OpenaiReasonClient(ReasonClient):
     def reason_stream(self,
                       messages: list[dict],
                       model: str,
+                      reason_system_prompt:Optional[str] = None,
                       **kwargs
                       ) -> Stream:
+        if reason_system_prompt is not None:
+            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+
         stream =  self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -177,11 +190,16 @@ class OpenaiReasonClient(ReasonClient):
             self,
             messages:list[dict],
             model:str,
+            reason_system_prompt:Optional[str] = None,
             stream = False,
             **kwargs
     ) -> Stream or chat_completion.ChatCompletion:
         if stream:
             return self.reason_stream(messages, model, **kwargs)
+
+        if reason_system_prompt is not None:
+            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+
         completion = self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -207,9 +225,13 @@ class AsyncOpenaiReasonClient(AsyncReasonClient):
     async def reason_stream(self,
                             messages: list[dict],
                             model: str,
+                            reason_system_prompt:Optional[str] = None,
                             **kwargs
                             ) -> AsyncStream:
 
+        if reason_system_prompt is not None:
+            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+
         stream =  await self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -226,12 +248,16 @@ class AsyncOpenaiReasonClient(AsyncReasonClient):
     async def reason(self,
                      messages: list[dict],
                      model: str,
+                     reason_system_prompt:Optional[str] = None,
                      stream = False,
                      **kwargs
                      ) -> AsyncStream or chat_completion.ChatCompletion:
         if stream:
             return await self.reason_stream(messages, model, **kwargs)
 
+        if reason_system_prompt is not None:
+            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+
         completion = await self.client.chat.completions.create(
             messages=messages,
             model=model,

{deepanything-0.1.6 → deepanything-0.1.7}/deepanything/Server/Server.py

@@ -10,12 +10,16 @@ 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
+import logging
+import logging.config
 
 from deepanything.DeepAnythingClient import chat_completion_stream_async, chat_completion_async
 from deepanything.ResponseClient import AsyncOpenaiResponseClient,AsyncResponseClient
 from deepanything.Stream import AsyncStream
 from deepanything.ReasonClient import AsyncDeepseekReasonClient,AsyncOpenaiReasonClient,AsyncReasonClient
 from deepanything.Server import Types
+from deepanything.metadatas import VERSION,PYTHON_RUNTIME
+
 
 @dataclass
 class ModelInfo:
@@ -25,12 +29,14 @@ class ModelInfo:
     response_client : str
     response_model : str
     created : int = int(time.time())
-    reason_prompt : str = "<Think>{}</Think>"
+    reason_prompt : str = "<Think>{}</Think>",
+    reason_system_prompt : Optional[str] = None
 
 class DeepAnythingServer:
     app : FastAPI = FastAPI()
     host : str
     port : int
+    logger : logging.Logger
     reason_clients : Dict[str,AsyncReasonClient] = {}
     response_clients : Dict[str,AsyncResponseClient] = {}
     models : Dict[str,ModelInfo] = {}
@@ -40,6 +46,7 @@ class DeepAnythingServer:
     log_config : Dict[str,Any] = LOGGING_CONFIG
 
     def __init__(self, host:str = None, port:int = None, config : Any or str = None):
+        print(f"DeepAnything Server {VERSION} on {PYTHON_RUNTIME}")
         if config is not None:
             if isinstance(config,str):
                 with open(config) as f:
@@ -54,7 +61,9 @@ class DeepAnythingServer:
         self.app.add_api_route("/v1/models",self.get_models,methods=["GET"],response_model=Types.ModelsListResponse)
         self.app.add_api_route("/v1/chat/completions",self.chat_completions,methods=["POST"])
 
+
     def run(self):
+        self.logger.info(f"DeepAnything server is now running at http://{self.host}:{self.port}")
         uvicorn.run(self.app,host=self.host,port=self.port,log_config=self.log_config)
 
     @staticmethod
@@ -65,21 +74,26 @@ class DeepAnythingServer:
         return args
 
     def load_config(self,config_object : Dict) -> None:
+        print("Loading config")
         self.host = config_object.get("host","0.0.0.0")
         self.port = config_object.get("port",8000)
         self.model_owner = config_object.get("model_owner","deepanything")
 
+        self.log_config = config_object.get("log",LOGGING_CONFIG)
+        if self.log_config == {}:
+            self.log_config = LOGGING_CONFIG
+        logging.config.dictConfig(self.log_config)
+        self.logger = logging.getLogger("deepanything")
+
         self._load_reason_clients(config_object)
         self._load_response_clients(config_object)
         self._load_models(config_object)
 
         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
 
 
     def _load_models(self, config_object):
+        self.logger.info("Loading models")
         models: List[Dict] = config_object.get("models", [])
         for _model in models:
             name = _model["name"]
@@ -89,12 +103,18 @@ class DeepAnythingServer:
             response_model = _model["response_model"]
             created = _model.get("created", int(time.time()))
             reason_prompt = _model.get("reason_prompt", "<Think>{}</Think>")
+            reason_system_prompt = _model.get("reason_system_prompt", None)
+
+            if name in self.models:
+                self.logger.error(f"Detected duplicate model : {name}")
 
             if reason_client not in self.reason_clients:
-                raise ValueError(f"Reason client '{reason_model}' for '{name}' not found")
+                self.logger.error(f"Reason client '{reason_model}' for '{name}' not found")
+                exit(0)
 
             if response_client not in self.response_clients:
-                raise ValueError(f"Response client '{response_model}' for '{name}' not found")
+                self.logger.error(f"Response client '{response_model}' for '{name}' not found")
+                exit(0)
 
             self.models[name] = ModelInfo(
                 name=name,
@@ -103,10 +123,14 @@ class DeepAnythingServer:
                 response_client=response_client,
                 response_model=response_model,
                 created=created,
-                reason_prompt=reason_prompt
+                reason_prompt=reason_prompt,
+                reason_system_prompt=reason_system_prompt
             )
 
+            self.logger.info(f"Loaded model : {name}")
+
     def _load_response_clients(self, config_object):
+        self.logger.info("Loading response clients")
         response_clients: List[Dict] = config_object.get("response_clients", [])
         for client in response_clients:
             name = client["name"]
@@ -114,12 +138,20 @@ class DeepAnythingServer:
             api_key = client.get("api_key", "")
             extract_args = client.get("extract_args", {})
 
+            if name in self.response_clients:
+                self.logger.error(f"Detected duplicate response clients : {name}")
+                exit(0)
+
             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']}'")
+                self.logger.error(f"Unsupported response client type '{client['type']}'")
+                exit(0)
+
+            self.logger.info(f"Loaded response client : {name}")
 
     def _load_reason_clients(self, config_object):
+        self.logger.info("Loading reason clients")
         reason_clients: List[Dict] = config_object.get("reason_clients", [])
         for client in reason_clients:
             name = client["name"]
@@ -127,12 +159,20 @@ class DeepAnythingServer:
             api_key = client.get("api_key", "")
             extract_args = client.get("extract_args", {})
 
+
+            if name in self.response_clients:
+                self.logger.error(f"Detected duplicate response clients : {name}")
+                exit(0)
+
             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")
+                self.logger.error(f"Unsupported reason client type '{client['type']}'")
+                exit(0)
+
+            self.logger.info(f"Loaded reason client : {name}")
 
     def add_reason_client(self,name:str,client:AsyncReasonClient):
         self.reason_clients[name] = client
@@ -143,31 +183,31 @@ class DeepAnythingServer:
     def add_model(self,name:str,model:ModelInfo):
         self.models[name] = model
 
+    @staticmethod
+    def _extract_token(authorization:str):
+        if (authorization is None) or (not authorization.startswith("Bearer ")):
+            return None
+        return authorization[7:]
     def _verify_authorization(self, authorization:Optional[str]):
+        token  = DeepAnythingServer._extract_token(authorization)
+
         if not self.api_keys:
-            return
+            return DeepAnythingServer._extract_token(authorization)
 
-        if authorization is None:
+        if authorization is None or token is None:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
                 detail="Expect token",
                 headers={"WWW-Authenticate": "Bearer"},
             )
 
-        if not authorization.startswith("Bearer "):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid or expired token",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-
-        token  =authorization[7:]
         if token not in self.api_keys:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
                 detail="Invalid or expired token",
                 headers={"WWW-Authenticate": "Bearer"},
             )
+        return token
 
     async def chat_completions(
             self,
@@ -175,7 +215,9 @@ class DeepAnythingServer:
             query: Types.ChatCompletionQuery,
             authorization: Optional[str] = Header(None)
     ):
-        self._verify_authorization(authorization)
+        token = self._verify_authorization(authorization)
+
+        self.logger.info(f"ChatCompletions : {token} -> {query.model}")
 
         if query.model not in self.models:
             raise HTTPException(
@@ -212,7 +254,8 @@ class DeepAnythingServer:
                     reason_prompt=model.reason_prompt,
                     response_args=args,
                     reason_args=args,
-                    max_tokens=max_tokens
+                    max_tokens=max_tokens,
+
                 ),
                 request
             )

{deepanything-0.1.6 → deepanything-0.1.7}/deepanything/Utility.py

@@ -6,6 +6,7 @@ import uuid
 from openai.types.chat import chat_completion_chunk,chat_completion,chat_completion_message
 from openai.types import completion_usage,completion_choice
 
+
 def make_usage(
         completion_tokens,
         prompt_tokens,
@@ -207,4 +208,16 @@ def merge_usage(
     )
 
 def make_id_by_timestamp():
-    return "chatcmpl-" + str(uuid.uuid4())
+    return "chatcmpl-" + str(uuid.uuid4())
+
+def attend_message(
+        messages : List,
+        role : Literal["developer", "system", "user", "assistant", "tool"],
+        content : Optional[str] = None,
+        reason_content : Optional[str] = None,
+) -> List:
+    return messages + [make_chat_completion_message(
+        role=role,
+        content=content,
+        reasoning_content=reason_content
+    )]

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

@@ -12,7 +12,7 @@ def main():
     args = parser.parse_args()
 
     if args.config is not None:
-        with open(args.config) as f:
+        with open(args.config, encoding='utf-8') as f:
             config = json.load(f)
         server = DeepAnythingServer(host=args.host, port=args.port, config=config)
         server.run()

deepanything-0.1.7/deepanything/metadatas.py

@@ -0,0 +1,4 @@
+from sys import version
+
+VERSION = "v0.1.7"
+PYTHON_RUNTIME = f"python{version}"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.6
+Version: 0.1.7
 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

{deepanything-0.1.6 → deepanything-0.1.7}/test/server.py

@@ -1,7 +1,7 @@
 from deepanything.Server.Server import DeepAnythingServer
 import json
 
-with open("test/config.json") as f:
+with open("test/config.json", encoding="utf-8") as f:
     conf = json.load(f)
 
 server = DeepAnythingServer(config=conf)

deepanything-0.1.6/deepanything/metadatas.py

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