deepanything 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

deepanything/ReasonClient.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import openai
 from openai.types.chat import chat_completion, chat_completion_chunk
 from deepanything.Stream import Stream,AsyncStream
@@ -5,6 +7,9 @@ from deepanything import Utility
 
 
 class ReasonClient:
+    """
+    Base Class for Reason Clients
+    """
     def __init__(self) -> None:
         pass
 
@@ -12,9 +17,20 @@ class ReasonClient:
             self,
             messages:list[dict],
             model:str,
+            reason_system_prompt:Optional[str] = None,
             stream = False,
             **kwargs
     ) -> Stream or chat_completion.ChatCompletion:
+        """
+        Generate reason content like Deepseek R1. This function returns a value that is almost the same as the OpenAI API, but 'content' is None and 'reasoning_content' is reason content.
+
+        :param messages: Messages
+        :param model: Model
+        :param reason_system_prompt: Adds extra prompt words for the thinking model. This prompt will be placed at the end of the message as a `system` role and passed to the thinking model. If not specified, it will not take effect.
+        :param stream: Whether you use streaming return
+        :param kwargs: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
         if stream:
             return self.reason_stream(messages, model, **kwargs)
 
@@ -26,11 +42,24 @@ class ReasonClient:
     def reason_stream(self,
                       messages:list[dict],
                       model:str,
+                      reason_system_prompt:Optional[str] = None,
                       **kwargs
                       ) -> Stream:
+        """
+        Generate reason content like Deepseek R1. This function returns a value that is almost the same as the OpenAI API, but 'content' is None and 'reasoning_content' is reason content.This method uses streaming return
+
+        :param messages: Messages
+        :param model: Model
+        :param reason_system_prompt: Adds extra prompt words for the thinking model. This prompt will be placed at the end of the message as a `system` role and passed to the thinking model. If not specified, it will not take effect.
+        :param kwargs: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
         raise NotImplementedError
 
 class AsyncReasonClient:
+    """
+    Base Class for Async Reason Clients
+    """
     def __init__(self) -> None:
         pass
 
@@ -38,9 +67,20 @@ class AsyncReasonClient:
             self,
             messages:list[dict],
             model:str,
+            reason_system_prompt:Optional[str] = None,
             stream = False,
             **kwargs
     ) -> AsyncStream or chat_completion.ChatCompletion:
+        """
+        Generate reason content like Deepseek R1. This function returns a value that is almost the same as the OpenAI API, but 'content' is None and 'reasoning_content' is reason content.
+
+        :param messages: Messages
+        :param model: Model
+        :param reason_system_prompt: Adds extra prompt words for the thinking model. This prompt will be placed at the end of the message as a `system` role and passed to the thinking model. If not specified, it will not take effect.
+        :param stream: Whether you use streaming return
+        :param kwargs: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
         if stream:
             return await self.reason_stream(messages, model, **kwargs)
 
@@ -52,14 +92,32 @@ class AsyncReasonClient:
     async def reason_stream(self,
                             messages:list[dict],
                             model:str,
+                            reason_system_prompt:Optional[str] = None,
                             **kwargs
                             ) -> AsyncStream:
+        """
+        Generate reason content like Deepseek R1. This function returns a value that is almost the same as the OpenAI API, but 'content' is None and 'reasoning_content' is reason content.This method uses streaming return
+
+        :param messages: Messages
+        :param model: Model
+        :param reason_system_prompt: Adds extra prompt words for the thinking model. This prompt will be placed at the end of the message as a `system` role and passed to the thinking model. If not specified, it will not take effect.
+        :param kwargs: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :return: Return a AsyncStream if stream is Ture,otherwise return a ChatCompletion
+        """
         raise NotImplementedError
 
 class DeepseekReasonClient(ReasonClient):
+    """
+    Deepseek Reason Client
+    """
     client : openai.OpenAI
 
     def __init__(self,base_url:str,api_key:str,**kwargs) -> None:
+        """
+        :param base_url: Base url
+        :param api_key: Api key
+        :param kwargs: Other parameters used to create clients
+        """
         super().__init__()
         self.client = openai.OpenAI(
             base_url=base_url,
@@ -70,6 +128,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(
@@ -95,9 +154,18 @@ class DeepseekReasonClient(ReasonClient):
                 .on_close(lambda _: stream.close()))
 
 class AsyncDeepseekReasonClient(AsyncReasonClient):
+    """
+    Deepseek Reason Async Client
+    """
     client : openai.AsyncOpenAI
 
     def __init__(self,base_url:str,api_key:str,**kwargs) -> None:
+        """
+        :param base_url: Base url
+        :param api_key: Api key
+        :param kwargs: Other parameters used to create clients
+        """
+
         super().__init__()
         self.client = openai.AsyncOpenAI(
             base_url=base_url,
@@ -108,6 +176,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(
@@ -144,6 +213,9 @@ def _rebuild_chunk_for_openai(
 
 
 class OpenaiReasonClient(ReasonClient):
+    """
+    OpenAI Reason Client.Used When using models similar to QWQ
+    """
     client : openai.OpenAI
     def __init__(
             self,
@@ -151,6 +223,11 @@ class OpenaiReasonClient(ReasonClient):
             api_key:str,
             **kwargs
     ) -> None:
+        """
+        :param base_url: Base url
+        :param api_key: Api key
+        :param kwargs: Other parameters used to create clients
+        """
         super().__init__()
         self.client = openai.OpenAI(
             base_url=base_url,
@@ -161,8 +238,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.extend_message(messages, role="system", content=reason_system_prompt)
+
         stream =  self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -177,11 +258,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.extend_message(messages, role="system", content=reason_system_prompt)
+
         completion = self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -195,8 +281,16 @@ class OpenaiReasonClient(ReasonClient):
         return completion
 
 class AsyncOpenaiReasonClient(AsyncReasonClient):
+    """
+    OpenAI Reason Async Client.Used When using models similar to QWQ
+    """
     client : openai.AsyncOpenAI
     def __init__(self,base_url:str,api_key:str,**kwargs) -> None:
+        """
+        :param base_url: Base url
+        :param api_key: Api key
+        :param kwargs: Other parameters used to create clients
+        """
         super().__init__()
         self.client = openai.AsyncOpenAI(
             base_url=base_url,
@@ -207,9 +301,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.extend_message(messages, role="system", content=reason_system_prompt)
+
         stream =  await self.client.chat.completions.create(
             messages=messages,
             model=model,
@@ -226,12 +324,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.extend_message(messages, role="system", content=reason_system_prompt)
+
         completion = await self.client.chat.completions.create(
             messages=messages,
             model=model,

deepanything/ResponseClient.py

@@ -5,36 +5,84 @@ import openai
 from deepanything import Utility
 
 class ResponseClient:
+    """
+    Base Class for Response Client
+    """
     def __init__(self):
         pass
 
     def chat_completions(self,messages,model,stream = False,**kwargs) -> Stream or chat_completion.ChatCompletion:
+        """
+        Make chat completion for responding
+
+        :param messages: Messages
+        :param model: Model
+        :param stream: Whether you use streaming return
+        :param kwargs: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
         if stream:
             return self.chat_completions_stream(messages,model,**kwargs)
 
         return Utility.merge_chunk(self.chat_completions_stream(messages,model,**kwargs),model)
 
     def chat_completions_stream(self,messages,model,**kwargs) -> Stream:
-        pass
+        """
+        Make chat completion for responding.This method uses streaming return
+
+        :param messages: Messages
+        :param model: Model
+        :param kwargs: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
+        raise NotImplementedError()
 
 class AsyncResponseClient:
+    """
+    Base Class for Response Async Client
+    """
     def __init__(self):
         pass
 
     async def chat_completions(self,messages,model,stream = False,**kwargs) -> AsyncStream or chat_completion.ChatCompletion:
+        """
+        Make chat completion for responding
+
+        :param messages: Messages
+        :param model: Model
+        :param stream: Whether you use streaming return
+        :param kwargs: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
         if stream:
             return self.chat_completions_stream(messages,model,**kwargs)
 
         return await Utility.async_merge_chunk(await self.chat_completions_stream(messages,model,**kwargs),model)
 
     async def chat_completions_stream(self,messages,model,**kwargs) -> AsyncStream:
-        pass
+        """
+        Make chat completion for responding.This method uses streaming return
 
+        :param messages: Messages
+        :param model: Model
+        :param kwargs: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
+        raise NotImplementedError()
 
 class OpenaiResponseClient(ResponseClient):
+    """
+    OpenAI-like response client
+    """
     client : openai.OpenAI
 
     def __init__(self,base_url,api_key,**kwargs):
+        """
+
+        :param base_url:  Base url
+        :param api_key: API Key
+        :param kwargs: Other parameters used to create clients
+        """
         super().__init__()
         self.client = openai.OpenAI(
             base_url=base_url,
@@ -61,9 +109,17 @@ class OpenaiResponseClient(ResponseClient):
 
 
 class AsyncOpenaiResponseClient(AsyncResponseClient):
+    """
+    OpenAI-like async response client
+    """
     client : openai.AsyncOpenAI
 
     def __init__(self,base_url,api_key,**kwargs):
+        """
+        :param base_url:  Base url
+        :param api_key: API Key
+        :param kwargs: Other parameters used to create clients
+        """
         super().__init__()
         self.client = openai.AsyncOpenAI(
             base_url=base_url,

deepanything/Server/Server.py

@@ -1,21 +1,24 @@
-from chunk import Chunk
-from dataclasses import dataclass
+import json
+import logging
+import logging.config
 import time
-import uvicorn
+from dataclasses import dataclass
 from typing import Dict, List, Optional, Any
-import json
 
+import uvicorn
+from fastapi import FastAPI, HTTPException, status, Header, Request
+from fastapi.responses import StreamingResponse, Response
+from fastapi.security import HTTPBearer
 from openai.types.model import Model as OpenaiModel
-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
-from deepanything.Stream import AsyncStream
-from deepanything.ReasonClient import AsyncDeepseekReasonClient,AsyncOpenaiReasonClient,AsyncReasonClient
+from deepanything.ReasonClient import AsyncDeepseekReasonClient, AsyncOpenaiReasonClient, AsyncReasonClient
+from deepanything.ResponseClient import AsyncOpenaiResponseClient, AsyncResponseClient
 from deepanything.Server import Types
+from deepanything.Stream import AsyncStream
+from deepanything.metadatas import VERSION, PYTHON_RUNTIME
+
 
 @dataclass
 class ModelInfo:
@@ -25,12 +28,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 +45,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 +60,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 +73,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"]
@@ -88,13 +101,19 @@ 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>")
+            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 +122,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 +137,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 +158,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 reason 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 +182,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 +214,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 +253,8 @@ class DeepAnythingServer:
                     reason_prompt=model.reason_prompt,
                     response_args=args,
                     reason_args=args,
-                    max_tokens=max_tokens
+                    max_tokens=max_tokens,
+
                 ),
                 request
             )

deepanything/Server/Types.py

@@ -1,6 +1,7 @@
-from pydantic import BaseModel
+from typing import List, Optional
+
 from openai.types.model import Model as OpenaiModel
-from typing import Dict, List, Optional
+from pydantic import BaseModel
 
 
 class ModelsListResponse(BaseModel):

deepanything/Stream.py

@@ -3,9 +3,12 @@ from typing import Any,  AsyncIterator,  Iterator
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 class Stream:
+    """
+    Implementation of streaming return. Implement using simple callback functions
+    """
     next_fc : Callable[[Any],ChatCompletionChunk]
     close_fc : Callable[[Any],None]
-    data : dict
+    data : Any
 
 
     def __init__(self,data):
@@ -14,10 +17,22 @@ class Stream:
         return self
 
     def on_next(self,fc : Callable[[Any],ChatCompletionChunk]) -> 'Stream':
+        """
+        Set callback for `__next__()`
+
+        :param fc: Callback
+        :return: Stream itself.
+        """
         self.next_fc = fc
         return self
 
     def on_close(self,fc : Callable[[Any],None]) -> 'Stream':
+        """
+        Set callback for `close()`
+
+        :param fc: Callback
+        :return: Stream itself.
+        """
         self.close_fc = fc
         return self
 
@@ -25,9 +40,16 @@ class Stream:
         return self.next_fc(self.data)
 
     def close(self) -> None:
+        """
+        Close the stream
+        :return: None
+        """
         self.close_fc(self.data)
 
 class AsyncStream:
+    """
+    Implementation of streaming return. Implement using simple callback functions
+    """
     next_fc: Callable[[Any], Awaitable[ChatCompletionChunk]]
     close_fc: Callable[[Any], Awaitable[None]]
     data : Any
@@ -39,10 +61,22 @@ class AsyncStream:
         return self
 
     def on_next(self, fc: Callable[[Any], Awaitable[ChatCompletionChunk]]) -> 'AsyncStream':
+        """
+        Set callback for `__anext__()`
+
+        :param fc: Callback
+        :return: Stream itself.
+        """
         self.next_fc = fc
         return self
 
     def on_close(self, fc: Callable[[Any], Awaitable[None]]) -> 'AsyncStream':
+        """
+        Set callback for `close()`
+
+        :param fc: Callback
+        :return: Stream itself.
+        """
         self.close_fc = fc
         return self
 
@@ -50,4 +84,8 @@ class AsyncStream:
         return await self.next_fc(self.data)
 
     async def close(self) -> None:
+        """
+        Close the stream
+        :return: None
+        """
         await self.close_fc(self.data)