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

deepanything/DeepAnythingClient.py

@@ -1,13 +1,14 @@
 import time
 from typing import Optional, List
+
 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, \
-    attend_message
-from deepanything.ResponseClient import ResponseClient,AsyncResponseClient
-from deepanything.ReasonClient import ReasonClient,AsyncReasonClient
+from deepanything.ReasonClient import ReasonClient, AsyncReasonClient
+from deepanything.ResponseClient import ResponseClient, AsyncResponseClient
+from deepanything.Stream import Stream, AsyncStream
+from deepanything.Utility import make_usage, make_chat_completion_message, make_chat_completion, \
+    make_chat_completion_choice, merge_usage, make_id_by_timestamp, \
+    extend_message
 
 
 def _merge_chat_completion(
@@ -42,7 +43,7 @@ def _build_message(
         reason_content : str,
         reason_prompt : str
 ) -> List:
-    return attend_message(messages,role="assistant",content=reason_prompt.format(reason_content))
+    return extend_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
@@ -80,13 +81,34 @@ def chat_completion(
         show_model: str,
         reason_args=None,
         response_args=None,
-        reason_prompt: str = "<Think>{}</Think>",
+        reason_prompt: str = "<think>{}</think>",
         reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         stream = False,
         _id: str = make_id_by_timestamp(),
         max_tokens : Optional[int] = None
     ) -> Stream or ChatCompletion:
+
+    """
+    Make chat completion synchronously.
+
+    :param messages: Messages
+    :param reason_client: Reason client
+    :param reason_model: Reason model
+    :param response_client: Response client
+    :param response_model: Response model
+    :param show_model: Specify the model name in the return value
+    :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+    :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+    :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+    :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 created: The timestamp indicating the time when the chat completion was created
+    :param stream: Whether you use streaming return
+    :param _id: Specify the `id` in the return value
+    :param max_tokens: max_tokens
+    :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+    """
+
     if response_args is None:
         response_args = {}
     if reason_args is None:
@@ -144,12 +166,32 @@ def chat_completion_stream(
         show_model: str,
         reason_args=None,
         response_args=None,
-        reason_prompt: str = "<Think>{}</Think>",
+        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
 ) -> Stream:
+
+    """
+    Make chat completion synchronously.This method uses streaming return
+
+    :param messages: Messages
+    :param reason_client: Reason client
+    :param reason_model: Reason model
+    :param response_client: Response client
+    :param response_model: Response model
+    :param show_model: Specify the model name in the return value
+    :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+    :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+    :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+    :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 created: The timestamp indicating the time when the chat completion was created
+    :param _id: Specify the `id` in the return value
+    :param max_tokens: max_tokens
+    :return: A stream
+    """
+
     if response_args is None:
         response_args = {}
     if reason_args is None:
@@ -207,13 +249,33 @@ async def chat_completion_async(
         show_model: str,
         reason_args=None,
         response_args=None,
-        reason_prompt: str = "<Think>{}</Think>",
+        reason_prompt: str = "<think>{}</think>",
         reason_system_prompt: Optional[str] = None,
         created: int = int(time.time()),
         _id: str = make_id_by_timestamp(),
         stream=False,
         max_tokens : Optional[int] = None
 ):
+    """
+    Make chat completion asynchronously.
+
+    :param messages: Messages
+    :param reason_client: Reason client
+    :param reason_model: Reason model
+    :param response_client: Response client
+    :param response_model: Response model
+    :param show_model: Specify the model name in the return value
+    :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+    :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+    :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+    :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 created: The timestamp indicating the time when the chat completion was created
+    :param stream: Whether you use streaming return
+    :param _id: Specify the `id` in the return value
+    :param max_tokens: max_tokens
+    :return: Return a AsyncStream if stream is Ture,otherwise return a ChatCompletion
+    """
+
     if response_args is None:
         response_args = {}
     if reason_args is None:
@@ -273,12 +335,31 @@ async def chat_completion_stream_async(
         show_model: str,
         reason_args=None,
         response_args=None,
-        reason_prompt: str = "<Think>{}</Think>",
+        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
 ) -> AsyncStream:
+    """
+    Make chat completion asynchronously.This method uses streaming return
+
+    :param messages: Messages
+    :param reason_client: Reason client
+    :param reason_model: Reason model
+    :param response_client: Response client
+    :param response_model: Response model
+    :param show_model: Specify the model name in the return value
+    :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+    :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+    :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+    :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 created: The timestamp indicating the time when the chat completion was created
+    :param _id: Specify the `id` in the return value
+    :param max_tokens: max_tokens
+    :return: A AsyncStream
+    """
+
     if response_args is None:
         response_args = {}
     if reason_args is None:
@@ -328,20 +409,32 @@ async def chat_completion_stream_async(
     return AsyncStream(_iter()).on_next(lambda it:it.__anext__()).on_close(lambda _:stream.close())
 
 class DeepAnythingClient:
+    """
+    DeepAnything Client
+    """
+
     reason_client : ReasonClient
     response_client : ResponseClient
-
-    reason_prompt : str
+    reason_prompt : Optional[str]
+    reason_system_prompt : Optional[str]
 
     def __init__(
             self,
             reason_client: ReasonClient,
             response_client: ResponseClient,
-            reason_prompt : str = "<Think>{}</Think>"
+            reason_prompt : str = None,
+            reason_system_prompt: Optional[str] = None
     ):
+        """
+        :param reason_client: Reason client
+        :param response_client: Response client
+        :param reason_prompt: Default value for reason_prompt
+        :param reason_system_prompt: Default value for reason_system_prompt
+        """
         self.reason_client = reason_client
         self.response_client = response_client
         self.reason_prompt = reason_prompt
+        self.reason_system_prompt = reason_system_prompt
 
     def chat_completion(
             self,
@@ -351,11 +444,35 @@ class DeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_prompt: Optional[str] = None,
             reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
             _id : str = make_id_by_timestamp(),
-            stream = False
+            stream = False,
+            max_tokens : Optional[int] = None
     ) -> Stream or ChatCompletion:
+        """
+        Make chat completion synchronously.
+
+        :param messages: Messages
+        :param reason_model: Reason model
+        :param response_model: Response model
+        :param show_model: Specify the model name in the return value
+        :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+        :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 created: The timestamp indicating the time when the chat completion was created
+        :param stream: Whether you use streaming return
+        :param _id: Specify the `id` in the return value
+        :param max_tokens: max_tokens
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
+        if reason_prompt is None:
+            reason_prompt = self.reason_prompt
+        if reason_system_prompt is None:
+            reason_system_prompt = self.reason_system_prompt
+
         return chat_completion(
             messages=messages,
             reason_model=reason_model,
@@ -365,11 +482,12 @@ class DeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_prompt=reason_prompt,
             reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             stream=stream,
-            reason_prompt=self.reason_prompt
+            max_tokens=max_tokens
         )
 
     def chat_completion_stream(
@@ -380,10 +498,33 @@ class DeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_prompt: Optional[str] = None,
             reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
-            _id : str = make_id_by_timestamp()
+            _id : str = make_id_by_timestamp(),
+            max_tokens : Optional[int] = None
     ) -> Stream:
+        """
+        Make chat completion synchronously.This method uses streaming return
+
+        :param messages: Messages
+        :param reason_model: Reason model
+        :param response_model: Response model
+        :param show_model: Specify the model name in the return value
+        :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+        :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+        :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+        :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 created: The timestamp indicating the time when the chat completion was created
+        :param _id: Specify the `id` in the return value
+        :param max_tokens: max_tokens
+        :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
+
+        if reason_prompt is None:
+            reason_prompt = self.reason_prompt
+        if reason_system_prompt is None:
+            reason_system_prompt = self.reason_system_prompt
         return chat_completion_stream(
             messages=messages,
             reason_model=reason_model,
@@ -393,28 +534,40 @@ class DeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_prompt=reason_prompt,
             reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
-            reason_prompt=self.reason_prompt
+            max_tokens=max_tokens
         )
 
 
 class AsyncDeepAnythingClient:
+    """
+        DeepAnything Async Client
+    """
     reason_client : AsyncReasonClient
     response_client : AsyncResponseClient
-
-    reason_prompt : str
+    reason_prompt : Optional[str]
+    reason_system_prompt : Optional[str]
 
     def __init__(
             self,
             reason_client: AsyncReasonClient,
             response_client: AsyncResponseClient,
-            reason_prompt : str = "<Think>{}</Think>"
+            reason_prompt : Optional[str] = None,
+            reason_system_prompt: Optional[str] = None
     ):
+        """
+        :param reason_client: Reason client
+        :param response_client: Response client
+        :param reason_prompt: Default value for reason_prompt
+        :param reason_system_prompt: Default value for reason_system_prompt
+        """
         self.reason_client = reason_client
         self.response_client = response_client
         self.reason_prompt = reason_prompt
+        self.reason_system_prompt = reason_system_prompt
 
     async def chat_completion(
             self,
@@ -424,11 +577,36 @@ class AsyncDeepAnythingClient:
             show_model: str,
             reason_args=None,
             response_args=None,
+            reason_prompt: Optional[str] = None,
             reason_system_prompt: Optional[str] = None,
             created: int = int(time.time()),
             _id: str = make_id_by_timestamp(),
-            stream=False
+            stream=False,
+            max_tokens : Optional[int] = None
     ):
+        """
+            Make chat completion asynchronously.
+
+            :param stream: Whether you use streaming return
+            :param messages: Messages
+            :param reason_model: Reason model
+            :param response_model: Response model
+            :param show_model: Specify the model name in the return value
+            :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+            :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+            :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+            :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 created: The timestamp indicating the time when the chat completion was created
+            :param _id: Specify the `id` in the return value
+            :param max_tokens: max_tokens
+            :return: Return an AsyncStream if stream is Ture,otherwise return a ChatCompletion
+        """
+
+        if reason_prompt is None:
+            reason_prompt = self.reason_prompt
+        if reason_system_prompt is None:
+            reason_system_prompt = self.reason_system_prompt
+
         return await chat_completion_async(
             messages=messages,
             reason_model=reason_model,
@@ -438,11 +616,12 @@ class AsyncDeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_prompt=reason_prompt,
             reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
             stream=stream,
-            reason_prompt=self.reason_prompt
+            max_tokens=max_tokens
         )
 
     async def chat_completion_stream(
@@ -453,10 +632,34 @@ class AsyncDeepAnythingClient:
             show_model : str,
             reason_args=None,
             response_args=None,
+            reason_prompt: Optional[str] = None,
             reason_system_prompt: Optional[str] = None,
             created : int = int(time.time()),
-            _id : str = make_id_by_timestamp()
+            _id : str = make_id_by_timestamp(),
+            max_tokens : Optional[int] = None
     ) -> AsyncStream:
+        """
+            Make chat completion asynchronously.This method uses streaming return
+
+            :param messages: Messages
+            :param reason_model: Reason model
+            :param response_model: Response model
+            :param show_model: Specify the model name in the return value
+            :param reason_args: Additional parameters passed to the reason client, such as temperature, top_k, etc.
+            :param response_args: Additional parameters passed to the response client, such as temperature, top_k, etc.
+            :param reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+            :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 created: The timestamp indicating the time when the chat completion was created
+            :param _id: Specify the `id` in the return value
+            :param max_tokens: max_tokens
+            :return: Return a Stream if stream is Ture,otherwise return a ChatCompletion
+        """
+
+        if reason_prompt is None:
+            reason_prompt = self.reason_prompt
+        if reason_system_prompt is None:
+            reason_system_prompt = self.reason_system_prompt
+
         return await chat_completion_stream_async(
             messages=messages,
             reason_model=reason_model,
@@ -466,8 +669,9 @@ class AsyncDeepAnythingClient:
             show_model=show_model,
             reason_args=reason_args,
             response_args=response_args,
+            reason_prompt=reason_prompt,
             reason_system_prompt=reason_system_prompt,
             created=created,
             _id=_id,
-            reason_prompt=self.reason_prompt
+            max_tokens=max_tokens
         )

deepanything/ReasonClient.py

@@ -1,13 +1,15 @@
 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
 
 
 class ReasonClient:
+    """
+    Base Class for Reason Clients
+    """
     def __init__(self) -> None:
         pass
 
@@ -19,6 +21,16 @@ class ReasonClient:
             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)
 
@@ -33,9 +45,21 @@ class ReasonClient:
                       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
 
@@ -47,6 +71,16 @@ class AsyncReasonClient:
             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)
 
@@ -61,12 +95,29 @@ class AsyncReasonClient:
                             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,
@@ -103,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,
@@ -153,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,
@@ -160,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,
@@ -174,7 +242,7 @@ class OpenaiReasonClient(ReasonClient):
                       **kwargs
                       ) -> Stream:
         if reason_system_prompt is not None:
-            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+            messages = Utility.extend_message(messages, role="system", content=reason_system_prompt)
 
         stream =  self.client.chat.completions.create(
             messages=messages,
@@ -198,7 +266,7 @@ class OpenaiReasonClient(ReasonClient):
             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)
+            messages = Utility.extend_message(messages, role="system", content=reason_system_prompt)
 
         completion = self.client.chat.completions.create(
             messages=messages,
@@ -213,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,
@@ -230,7 +306,7 @@ class AsyncOpenaiReasonClient(AsyncReasonClient):
                             ) -> AsyncStream:
 
         if reason_system_prompt is not None:
-            messages = Utility.attend_message(messages,role="system",content=reason_system_prompt)
+            messages = Utility.extend_message(messages, role="system", content=reason_system_prompt)
 
         stream =  await self.client.chat.completions.create(
             messages=messages,
@@ -256,7 +332,7 @@ class AsyncOpenaiReasonClient(AsyncReasonClient):
             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)
+            messages = Utility.extend_message(messages, role="system", content=reason_system_prompt)
 
         completion = await self.client.chat.completions.create(
             messages=messages,

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,24 +1,23 @@
-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
-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.ReasonClient import AsyncDeepseekReasonClient, AsyncOpenaiReasonClient, AsyncReasonClient
+from deepanything.ResponseClient import AsyncOpenaiResponseClient, AsyncResponseClient
 from deepanything.Server import Types
-from deepanything.metadatas import VERSION,PYTHON_RUNTIME
+from deepanything.Stream import AsyncStream
+from deepanything.metadatas import VERSION, PYTHON_RUNTIME
 
 
 @dataclass
@@ -29,7 +28,7 @@ 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:
@@ -102,7 +101,7 @@ 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:
@@ -161,7 +160,7 @@ class DeepAnythingServer:
 
 
             if name in self.response_clients:
-                self.logger.error(f"Detected duplicate response clients : {name}")
+                self.logger.error(f"Detected duplicate reason clients : {name}")
                 exit(0)
 
             if client["type"] == 'deepseek':

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)

deepanything/Utility.py

@@ -210,7 +210,7 @@ def merge_usage(
 def make_id_by_timestamp():
     return "chatcmpl-" + str(uuid.uuid4())
 
-def attend_message(
+def extend_message(
         messages : List,
         role : Literal["developer", "system", "user", "assistant", "tool"],
         content : Optional[str] = None,

deepanything/metadatas.py

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

{deepanything-0.1.7.dist-info → deepanything-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepanything
-Version: 0.1.7
+Version: 0.1.8
 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
@@ -169,6 +169,12 @@ Below is an example of a configuration file:
       "type" : "deepseek",
       "base_url" : "https://api.siliconflow.cn/v1",
       "api_key" : "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    },
+    {
+      "name" : "qwen",
+      "type" : "openai",
+      "base_url" : "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      "api_key" : "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
     }
   ],
   "response_clients": [
@@ -185,7 +191,17 @@ Below is an example of a configuration file:
       "reason_client" : "siliconflow",
       "response_client" : "qwen",
       "reason_model": "Pro/deepseek-ai/DeepSeek-R1",
-      "response_model" :  "qwen-max-latest"
+      "response_model" :  "qwen-max-latest",
+      "reason_prompt" : "<think>{}</think>"
+    },
+    {
+      "name": "QWQ-Qwen-max",
+      "reason_client" : "qwen",
+      "response_client" : "qwen",
+      "reason_model": "qwq-32b-preview",
+      "response_model" :  "qwen-max-latest",
+      "reason_prompt" : "<think>{}</think>",
+      "reason_system_prompt" : "You are a model designed to contemplate questions before providing answers. Your thought process and responses are not directly visible to the user but are instead passed as prompts to the next model. For any question posed by the user, you should carefully consider it and provide as detailed a thought process as possible."
     }
   ],
   "api_keys" : [
@@ -220,7 +236,8 @@ Below is an example of a configuration file:
     "loggers": {
         "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": false},
         "uvicorn.error": {"level": "INFO"},
-        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false}
+        "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": false},
+        "deepanything": {"handlers": ["default"], "level": "INFO", "propagate": false}
     }
   }
 }
@@ -228,13 +245,17 @@ Below is an example of a configuration file:
 
 #### **Detailed Explanation**
 
-- 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).
+- reason_clients: Configuration for the thinking model, currently supporting two types: deepseek and openai. When the type is openai, DeepAnything directly uses the model's output as the thinking content; it is recommended to use qwq-32b in this case.
+- response_clients: Configuration for the response model, currently supporting only one type: openai.
+- models: Model configuration, including model name, thinking model, response model, parameters for the thinking model, and parameters for the response model.
+    - reason_prompt: Specifies how the thinking content should be embedded into the conversation. DeepAnything will use `reason_prompt` to format the thinking content. The default is `<think>{}</think>`.
+    - 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.
+- api_keys: API keys used for user identity verification. When not filled or an empty list, the server does not use API keys for authentication.
+- log: Log configuration. If this item is not filled, the default uvicorn log configuration will be used. For more details, refer to [uvicorn logging configuration](https://www.uvicorn.org/settings/#logging) and [Python Logging configuration](https://docs.python.org/3/library/logging.config.html).}
 
 ## Deploying with Docker
 ### 1. Pull the Image
+
 ```bash
 docker pull junity233/deepanything:latest
 ```

deepanything-0.1.8.dist-info/RECORD

@@ -0,0 +1,17 @@
+deepanything/DeepAnythingClient.py,sha256=4dJg5CFsQLlhxCWgtj7UYa9VTchogeFm_-B3YExk8Ns,28622
+deepanything/ReasonClient.py,sha256=P1uuwfgds6qch5gPp2BKD1y1myLPZ8BKCs1PiqsZHmw,12888
+deepanything/ResponseClient.py,sha256=BT-5qBv1xs3-5SbYfFEjHYzH0E09I4Fl8h4K1IvSJ8U,5089
+deepanything/Stream.py,sha256=8GSsKeAhSwSt0T6JAO4l3ivTwGuJYMxp7GlqpExp8T8,2440
+deepanything/Utility.py,sha256=dZeCg_D28rwJILLuCsE-ZtcKUkbW1prXPVlpSkYFCKA,7024
+deepanything/__init__.py,sha256=_2RolcKcpxmW0dmtiQpXlvgxe5dvqx90Yg_Q_oVLVZQ,175
+deepanything/__main__.py,sha256=BWGtAVWDgJg50uGTEvZNV4P4PFghYwx5cTpXlEAWRio,1084
+deepanything/metadatas.py,sha256=hfYSJI8zYLB9fgn5puFIHPQWxuMPY_n-YXoSW7y0XZ0,82
+deepanything/Server/Server.py,sha256=avsTMQVtX9RErhKm2JqYt_U_auUyhHiE4u-Xu1zPzOI,11460
+deepanything/Server/Types.py,sha256=yGd1vwYMg2nXXOdFh6esHfrAjCglkg9ivqzBMA4go6Y,646
+deepanything/Server/__init__.py,sha256=eIpn6NbNvEg4ST8CuuIuzPT3m_fTlmPC3sikPoPFsYo,92
+deepanything-0.1.8.dist-info/LICENSE,sha256=JWYd2E-mcNcSYjT5nk4ayM5kkkDq6ZlOxVcYsyqCIwU,1059
+deepanything-0.1.8.dist-info/METADATA,sha256=iLcSCMcTt4SpS5VweRtGlUDrU3Bp9GpCc12j9qWoWbI,9486
+deepanything-0.1.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+deepanything-0.1.8.dist-info/entry_points.txt,sha256=UT4gNGx6dJsKBjZIl3VkMekh385O5WMbMidAAla6UB4,60
+deepanything-0.1.8.dist-info/top_level.txt,sha256=wGeRb__4jEJTclCUl0cxhgubD_Bq-QT38VIH6C4KpzY,13
+deepanything-0.1.8.dist-info/RECORD,,

deepanything-0.1.7.dist-info/RECORD

@@ -1,17 +0,0 @@
-deepanything/DeepAnythingClient.py,sha256=uhRQMg1y9O9maHG-sw0lDUx_1-aWCZVb4cvgoGlRdAs,16177
-deepanything/ReasonClient.py,sha256=Sbv36lreZksBG_X_Q4NKiBuG4vsZ50YhhkWAxuwIu-4,8868
-deepanything/ResponseClient.py,sha256=NbXjlU_0qTKBNjZy8B9J9emuABQYvx3NZsWuja9OnMI,2989
-deepanything/Stream.py,sha256=8ESR8ttjyPZ-uXPDENsVWUzaL34_GT2OZBJ0PWu7vsA,1578
-deepanything/Utility.py,sha256=LRyawSCVpo5RjcaFFSwIqjsL3JGZpl48KM_KXn_-8ew,7024
-deepanything/__init__.py,sha256=_2RolcKcpxmW0dmtiQpXlvgxe5dvqx90Yg_Q_oVLVZQ,175
-deepanything/__main__.py,sha256=BWGtAVWDgJg50uGTEvZNV4P4PFghYwx5cTpXlEAWRio,1084
-deepanything/metadatas.py,sha256=iACXZlK9YOj5N8U2AdXEY_3EP4uobqpweN6DpVEVNj8,82
-deepanything/Server/Server.py,sha256=K9GUVl_c22LSeNW8qCFSpuw3SpUqBulVXymwsF9JwqM,11518
-deepanything/Server/Types.py,sha256=b7aMaRBgODEKdyYe0FeraUfrygJuye3b5lfQTOWASXA,650
-deepanything/Server/__init__.py,sha256=eIpn6NbNvEg4ST8CuuIuzPT3m_fTlmPC3sikPoPFsYo,92
-deepanything-0.1.7.dist-info/LICENSE,sha256=JWYd2E-mcNcSYjT5nk4ayM5kkkDq6ZlOxVcYsyqCIwU,1059
-deepanything-0.1.7.dist-info/METADATA,sha256=OAFhDpn_XllHi_Rzm25OsATxG4uh-mEiA1obS3DuH90,7851
-deepanything-0.1.7.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-deepanything-0.1.7.dist-info/entry_points.txt,sha256=UT4gNGx6dJsKBjZIl3VkMekh385O5WMbMidAAla6UB4,60
-deepanything-0.1.7.dist-info/top_level.txt,sha256=wGeRb__4jEJTclCUl0cxhgubD_Bq-QT38VIH6C4KpzY,13
-deepanything-0.1.7.dist-info/RECORD,,