deepanything 0.1.0__py3-none-any.whl

deepanything/ResponseClient.py

@@ -0,0 +1,87 @@
+from deepanything.Stream import Stream,AsyncStream
+from openai.types.chat import chat_completion
+import openai
+
+from deepanything import Utility
+
+class ResponseClient:
+    def __init__(self):
+        pass
+
+    def chat_completions(self,messages,model,stream = False,**kwargs) -> Stream or chat_completion.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
+
+class AsyncResponseClient:
+    def __init__(self):
+        pass
+
+    async def chat_completions(self,messages,model,stream = False,**kwargs) -> AsyncStream or chat_completion.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
+
+
+class OpenaiResponseClient(ResponseClient):
+    client : openai.OpenAI
+
+    def __init__(self,base_url,api_key,**kwargs):
+        super().__init__()
+        self.client = openai.OpenAI(
+            base_url=base_url,
+            api_key=api_key,
+            **kwargs
+        )
+
+    def chat_completions(self,messages,model,stream = False,**kwargs) -> Stream or chat_completion.ChatCompletion:
+        return self.client.chat.completions.create(
+            messages=messages,
+            model=model,
+            stream=stream,
+            **kwargs
+        )
+
+    def chat_completions_stream(self,messages,model,**kwargs) -> Stream:
+        return self.client.chat.completions.create(
+                messages=messages,
+                model=model,
+                stream=True,
+                **kwargs
+            )
+
+
+class AsyncOpenaiResponseClient(AsyncResponseClient):
+    client : openai.AsyncOpenAI
+
+    def __init__(self,base_url,api_key,**kwargs):
+        super().__init__()
+        self.client = openai.AsyncOpenAI(
+            base_url=base_url,
+            api_key=api_key,
+            **kwargs
+        )
+
+    async def chat_completions(self,messages,model,stream = False,**kwargs) -> AsyncStream or chat_completion.ChatCompletion:
+        return await self.client.chat.completions.create(
+            messages=messages,
+            model=model,
+            stream=stream,
+            **kwargs
+        )
+
+    async def chat_completions_stream(self,messages,model,**kwargs) -> AsyncStream:
+        return await self.client.chat.completions.create(
+                messages=messages,
+                model=model,
+                stream=True,
+                **kwargs
+            )

deepanything/Server/Server.py

@@ -0,0 +1,181 @@
+from dataclasses import dataclass
+import time
+import uvicorn
+from typing import Dict, List, Optional
+
+from openai.types.model import Model as OpenaiModel
+from fastapi import FastAPI,Depends, HTTPException, status,Header
+from fastapi.responses import StreamingResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+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
+
+@dataclass
+class ModelInfo:
+    name : str
+    reason_client : str
+    reason_model : str
+    response_client : str
+    response_model : str
+    created : int
+    reason_prompt : str
+
+class DeepAnythingServer:
+    app : FastAPI = FastAPI()
+    host : str
+    port : int
+    reason_clients : Dict[str,AsyncReasonClient] = {}
+    response_clients : Dict[str,AsyncResponseClient] = {}
+    models : Dict[str,ModelInfo] = {}
+    model_owner : str = "deepanything"
+    api_keys : List[str] = []
+    security = HTTPBearer()
+
+    def __init__(self, host:str = None, port:int = None,config_object : Dict = None):
+        if config_object is not None:
+            self.load_config(config_object)
+
+        if host:
+            self.host = host
+        if port:
+            self.port = port
+
+        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):
+        uvicorn.run(self.app,host=self.host,port=self.port,log_level="trace")
+
+    def load_config(self,config_object : Dict) -> None:
+        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")
+
+        reason_clients:List[Dict] = config_object.get("reason_clients",[])
+
+        for client in reason_clients:
+            name = client["name"]
+            base_url = client["base_url"]
+            api_key = client.get("api_key","")
+            extract_args = client.get("extract_args",{})
+
+            if client["type"] == 'deepseek':
+                self.reason_clients[name] = AsyncDeepseekReasonClient(base_url, api_key, **extract_args)
+            elif client["type"] == 'openai':
+                self.reason_clients[name] = AsyncOpenaiReasonClient(base_url, api_key, **extract_args)
+            else:
+                raise Exception("unknown reason client type")
+
+        response_clients : List[Dict] = config_object.get("response_clients",[])
+
+        for client in response_clients:
+            name = client["name"]
+            base_url = client["base_url"]
+            api_key = client.get("api_key","")
+            extract_args = client.get("extract_args",{})
+
+            if client["type"] == 'openai':
+                self.response_clients[name] = AsyncOpenaiResponseClient(base_url,api_key,**extract_args)
+            else:
+                raise Exception("unknown response client type")
+
+        models : List[Dict] = config_object.get("models",[])
+
+        for _model in models:
+            name = _model["name"]
+            reason_client = _model["reason_client"]
+            reason_model = _model["reason_model"]
+            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>")
+
+            self.models[name] = ModelInfo(
+                name = name,
+                reason_client = reason_client,
+                reason_model = reason_model,
+                response_client = response_client,
+                response_model = response_model,
+                created = created,
+                reason_prompt = reason_prompt
+            )
+
+        self.api_keys = config_object.get("api_keys",[])
+
+    def verify_authorization(self, authorization:Optional[str]):
+        if self.api_keys == []:
+            return
+
+        if authorization 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"},
+            )
+
+    async def chat_completions(self, query : Types.ChatCompletionQuery, authorization:Optional[str] = Header(None)):
+        self.verify_authorization(authorization)
+        model = self.models[query.model]
+        async def sse(it: AsyncStream):
+            async for chunk in it:
+                yield f"data: {chunk.model_dump_json(indent=None)}\n\n"
+            yield "data: [DONE]"
+
+        if query.stream:
+            res = sse(
+                await chat_completion_stream_async(
+                    messages=query.messages,
+                    reason_client=self.reason_clients[model.reason_client],
+                    reason_model=model.reason_model,
+                    response_client=self.response_clients[model.response_client],
+                    response_model=model.response_model,
+                    show_model=model.name,
+                    reason_prompt=model.reason_prompt,
+                )
+            )
+            return StreamingResponse(
+                res,
+                media_type="text/event-stream"
+            )
+        else:
+            res = await chat_completion_async(
+                    messages=query.messages,
+                    reason_client=self.reason_clients[model.reason_client],
+                    reason_model=model.reason_model,
+                    response_client=self.response_clients[model.response_client],
+                    response_model=model.response_model,
+                    show_model=model.name,
+                    reason_prompt=model.reason_prompt
+            )
+            return res.model_dump_json()
+
+    async def get_models(self) -> Types.ModelsListResponse:
+        return Types.ModelsListResponse(
+            data = [OpenaiModel(
+                    id = model_info.name,
+                    owned_by = self.model_owner,
+                    created = model_info.created,
+                    object = "model"
+                )
+                for model_info in self.models.values()
+            ]
+        )

deepanything/Server/Types.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from openai.types.model import Model as OpenaiModel
+from typing import Dict,List
+
+class ModelsListResponse(BaseModel):
+    data : List[OpenaiModel]
+
+class ChatCompletionMessage(BaseModel):
+    role : str
+    content : str
+
+class ChatCompletionQuery(BaseModel):
+    model : str
+    messages : List[ChatCompletionMessage]
+    stream : bool = False

deepanything/Server/__init__.py

@@ -0,0 +1 @@
+__all__ = ["Server", "Types"]

deepanything/Stream.py

@@ -0,0 +1,53 @@
+from collections.abc import Callable, Awaitable
+from typing import Any,  AsyncIterator,  Iterator
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+class Stream:
+    next_fc : Callable[[Any],ChatCompletionChunk]
+    close_fc : Callable[[Any],None]
+    data : dict
+
+
+    def __init__(self,data):
+        self.data = data
+    def __iter__(self) -> Iterator[ChatCompletionChunk]:
+        return self
+
+    def on_next(self,fc : Callable[[Any],ChatCompletionChunk]) -> 'Stream':
+        self.next_fc = fc
+        return self
+
+    def on_close(self,fc : Callable[[Any],None]) -> 'Stream':
+        self.close_fc = fc
+        return self
+
+    def __next__(self) -> ChatCompletionChunk:
+        return self.next_fc(self.data)
+
+    def close(self) -> None:
+        self.close_fc(self.data)
+
+class AsyncStream:
+    next_fc: Callable[[Any], Awaitable[ChatCompletionChunk]]
+    close_fc: Callable[[Any], Awaitable[None]]
+    data : Any
+
+    def __init__(self,data):
+        self.data = data
+
+    def __aiter__(self) -> AsyncIterator[ChatCompletionChunk]:
+        return self
+
+    def on_next(self, fc: Callable[[Any], Awaitable[ChatCompletionChunk]]) -> 'AsyncStream':
+        self.next_fc = fc
+        return self
+
+    def on_close(self, fc: Callable[[Any], Awaitable[None]]) -> 'AsyncStream':
+        self.close_fc = fc
+        return self
+
+    async def __anext__(self) -> ChatCompletionChunk:
+        return await self.next_fc(self.data)
+
+    async def close(self) -> None:
+        await self.close_fc(self.data)

deepanything/Utility.py

@@ -0,0 +1,210 @@
+import time
+from collections.abc import Iterable
+from typing import Optional, List, Literal, AsyncIterable
+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,
+        total_tokens
+) -> completion_usage.CompletionUsage:
+    usage = completion_usage.CompletionUsage(
+        completion_tokens = completion_tokens,
+        prompt_tokens = prompt_tokens,
+        total_tokens = total_tokens
+    )
+
+    return usage
+
+def make_chat_completion_chunk_delta(
+        role : Literal["developer", "system", "user", "assistant", "tool"],
+        content : Optional[str] = None,
+        reasoning_content : Optional[str] = None
+) -> chat_completion_chunk.ChoiceDelta:
+    delta = chat_completion_chunk.ChoiceDelta(
+        role = role,
+        content = content
+    )
+
+    delta.reasoning_content = reasoning_content
+
+    return delta
+
+def make_chat_completion_chunk_choice(
+        delta : chat_completion_chunk.ChoiceDelta,
+        index : int = 0,
+        finish_reason: Optional[Literal["stop", "length", "tool_calls", "content_filter", "function_call"]] = None,
+) -> chat_completion_chunk.Choice:
+    choice = chat_completion_chunk.Choice(
+        delta = delta,
+        index = index,
+        finish_reason = finish_reason
+    )
+
+    return choice
+
+
+def make_chat_completion_chunk(
+        _id : str,
+        usage : Optional[chat_completion_chunk.CompletionUsage],
+        model : str,
+        choices : List[completion_choice.CompletionChoice],
+        created : int = int(time.time()),
+) -> chat_completion_chunk.ChatCompletionChunk:
+    chunk = chat_completion_chunk.ChatCompletionChunk(
+        id = _id,
+        created = created,
+        model = model,
+        choices = choices,
+        object = "chat.completion.chunk",
+        usage = usage
+    )
+
+    return chunk
+
+
+def make_chat_completion_message(
+    role : Literal["developer", "system", "user", "assistant", "tool"],
+    content : Optional[str] = None,
+    reasoning_content : Optional[str] = None
+) -> chat_completion_message.ChatCompletionMessage:
+    message = chat_completion_message.ChatCompletionMessage(
+        role = role
+    )
+
+    message.content = content
+    message.reasoning_content = reasoning_content
+
+    return message
+
+def make_chat_completion_choice(
+    finish_reason: Literal["stop", "length", "tool_calls", "content_filter", "function_call"],
+    message :chat_completion_message.ChatCompletionMessage,
+    index : int = 0
+) -> chat_completion.Choice:
+    choice = chat_completion.Choice(
+        message = message,
+        finish_reason = finish_reason,
+        index = index,
+        logprobs = None
+    )
+    return choice
+
+
+def make_chat_completion(
+        _id : str,
+        choices : List[chat_completion.Choice],
+        model : str,
+        usage : Optional[chat_completion.CompletionUsage],
+        created : int = int(time.time()),
+) -> chat_completion.ChatCompletion:
+    res = chat_completion.ChatCompletion(
+        object="chat.completion",
+        id = _id,
+        choices = choices,
+        model = model,
+        usage = usage,
+        created = created,
+        system_fingerprint = None
+    )
+
+    return res
+
+
+def _update_accumulators(
+        reasoning: str,
+        content: str,
+        comp_tokens: int,
+        prompt_tokens: int,
+        total_tokens: int,
+        chunk: chat_completion_chunk.ChatCompletionChunk
+) -> tuple[str, str, int, int, int]:
+    delta = chunk.choices[0].delta
+
+    if delta.content is None:
+        reasoning += delta.reasoning_content or ""
+    else:
+        content += delta.content or ""
+
+    if chunk.usage is not None:
+        comp_tokens,prompt_tokens,total_tokens = chunk.usage.completion_tokens,chunk.usage.prompt_tokens,chunk.usage.total_tokens
+
+    return reasoning, content, comp_tokens, prompt_tokens, total_tokens
+
+
+def _build_final_completion(
+        model: str,
+        created: int,
+        reasoning_content: str,
+        content: str,
+        comp_tokens: int,
+        prompt_tokens: int,
+        total_tokens: int
+) -> chat_completion.ChatCompletion:
+
+    usage = make_usage(comp_tokens, prompt_tokens, total_tokens)
+
+    return make_chat_completion(
+        _id=str(uuid.uuid4()),
+        choices=[make_chat_completion_choice(
+            finish_reason="stop",
+            message=make_chat_completion_message(
+                role="assistant",
+                reasoning_content=reasoning_content if reasoning_content else None,
+                content=content if content else None
+            )
+        )],
+        model=model,
+        usage=usage,
+        created=created
+    )
+
+
+def merge_chunk(
+        chunks: Iterable[chat_completion_chunk.ChatCompletionChunk],
+        model: str,
+        created: int = int(time.time())
+) -> chat_completion.ChatCompletion:
+    """同步合并 chunk 流"""
+    reasoning_content = ""
+    content = ""
+    comp_tokens = prompt_tokens = total_tokens = 0
+
+    for chunk in chunks:
+        reasoning_content, content, comp_tokens, prompt_tokens, total_tokens = \
+            _update_accumulators(reasoning_content, content, comp_tokens, prompt_tokens, total_tokens, chunk)
+
+    return _build_final_completion(model, created, reasoning_content, content, comp_tokens, prompt_tokens, total_tokens)
+
+
+async def async_merge_chunk(
+        chunks: AsyncIterable[chat_completion_chunk.ChatCompletionChunk],
+        model: str,
+        created: int = int(time.time())
+) -> chat_completion.ChatCompletion:
+    """异步合并 chunk 流"""
+    reasoning_content = ""
+    content = ""
+    comp_tokens = prompt_tokens = total_tokens = 0
+
+    async for chunk in chunks:
+        reasoning_content, content, comp_tokens, prompt_tokens, total_tokens = \
+            _update_accumulators(reasoning_content, content, comp_tokens, prompt_tokens, total_tokens, chunk)
+
+    return _build_final_completion(model, created, reasoning_content, content, comp_tokens, prompt_tokens, total_tokens)
+
+def merge_usage(
+        a:completion_usage.CompletionUsage,
+        b:completion_usage.CompletionUsage
+) -> completion_usage.CompletionUsage:
+    return make_usage(
+        completion_tokens=a.completion_tokens + b.completion_tokens,
+        prompt_tokens=a.prompt_tokens + b.prompt_tokens,
+        total_tokens=a.total_tokens + b.total_tokens
+    )
+
+def make_id_by_timestamp():
+    return "chatcmpl-" + str(uuid.uuid4())

deepanything/__init__.py

@@ -0,0 +1 @@
+__all__ = ['DeepAnythingClient', 'ReasonClient', 'Utility', 'Stream', 'ResponseClient', 'Server']

deepanything/__main__.py

@@ -0,0 +1,21 @@
+from deepanything.Server.Server import DeepAnythingServer
+import argparse
+import json
+def main():
+    parser = argparse.ArgumentParser(prog="deepanything",description="Run a DeepAnything Server.")
+    parser.add_argument('--host', type=str, required=False, help='Specific the host to listen.If specified,the host will be overwritten by this.')
+    parser.add_argument('--port', type=int, required=False, help='Specific the port to listen.If specified,the port will be overwritten by this.')
+    parser.add_argument('--config', type=str, required=True, help='Specific the confi path.')
+
+    args = parser.parse_args()
+
+    if args.config is not None:
+        with open(args.config) as f:
+            config = json.load(f)
+        server = DeepAnythingServer(host=args.host,port=args.port,config_object=config)
+        server.run()
+    else:
+        print("No config file specified.")
+
+if __name__ == "__main__":
+    main()

deepanything-0.1.0.dist-info/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Junity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.