LLM-Bridge 0.1.4__tar.gz

llm_bridge-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 windsnow1025
+
+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.

llm_bridge-0.1.4/LLM_Bridge.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: LLM-Bridge
+Version: 0.1.4
+Summary: A Bridge for LLMs
+Author: windsnow1025
+Author-email: windsnow125@gmail.com
+License: MIT
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: openai
+Requires-Dist: google-genai
+Requires-Dist: anthropic
+Requires-Dist: tiktoken
+Requires-Dist: pillow
+Requires-Dist: PyMuPDF
+Requires-Dist: python-docx
+Requires-Dist: openpyxl
+Requires-Dist: python-pptx
+Requires-Dist: pytest
+Requires-Dist: pytest-asyncio
+Requires-Dist: python-dotenv
+Requires-Dist: protobuf
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

llm_bridge-0.1.4/LLM_Bridge.egg-info/SOURCES.txt

@@ -0,0 +1,56 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+LLM_Bridge.egg-info/PKG-INFO
+LLM_Bridge.egg-info/SOURCES.txt
+LLM_Bridge.egg-info/dependency_links.txt
+LLM_Bridge.egg-info/requires.txt
+LLM_Bridge.egg-info/top_level.txt
+llm_bridge/__init__.py
+llm_bridge/client/__init__.py
+llm_bridge/client/chat_client.py
+llm_bridge/client/implementations/__init__.py
+llm_bridge/client/implementations/claude/__init__.py
+llm_bridge/client/implementations/claude/non_stream_claude_client.py
+llm_bridge/client/implementations/claude/stream_claude_client.py
+llm_bridge/client/implementations/gemini/__init__.py
+llm_bridge/client/implementations/gemini/gemini_response_handler.py
+llm_bridge/client/implementations/gemini/non_stream_gemini_client.py
+llm_bridge/client/implementations/gemini/stream_gemini_client.py
+llm_bridge/client/implementations/gpt/__init__.py
+llm_bridge/client/implementations/gpt/non_stream_gpt_client.py
+llm_bridge/client/implementations/gpt/stream_gpt_client.py
+llm_bridge/client/model_client/__init__.py
+llm_bridge/client/model_client/claude_client.py
+llm_bridge/client/model_client/gemini_client.py
+llm_bridge/client/model_client/gpt_client.py
+llm_bridge/logic/__init__.py
+llm_bridge/logic/chat_generate/__init__.py
+llm_bridge/logic/chat_generate/chat_client_factory.py
+llm_bridge/logic/chat_generate/media_processor.py
+llm_bridge/logic/chat_generate/model_client_factory/__init__.py
+llm_bridge/logic/chat_generate/model_client_factory/claude_client_factory.py
+llm_bridge/logic/chat_generate/model_client_factory/gemini_client_factory.py
+llm_bridge/logic/chat_generate/model_client_factory/gpt_client_factory.py
+llm_bridge/logic/chat_generate/model_message_converter/__init__.py
+llm_bridge/logic/chat_generate/model_message_converter/claude_message_converter.py
+llm_bridge/logic/chat_generate/model_message_converter/gemini_message_converter.py
+llm_bridge/logic/chat_generate/model_message_converter/gpt_message_converter.py
+llm_bridge/logic/chat_generate/model_message_converter/model_message_converter.py
+llm_bridge/logic/message_preprocess/__init__.py
+llm_bridge/logic/message_preprocess/code_file_extensions.py
+llm_bridge/logic/message_preprocess/document_processor.py
+llm_bridge/logic/message_preprocess/file_type_checker.py
+llm_bridge/logic/message_preprocess/message_preprocessor.py
+llm_bridge/type/__init__.py
+llm_bridge/type/chat_response.py
+llm_bridge/type/message.py
+llm_bridge/type/serializer.py
+llm_bridge/type/model_message/__init__.py
+llm_bridge/type/model_message/claude_message.py
+llm_bridge/type/model_message/gemini_message.py
+llm_bridge/type/model_message/gpt_message.py
+tests/__init__.py
+tests/chat_client_factory_test.py
+tests/message_preprocessor_test.py

llm_bridge-0.1.4/LLM_Bridge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

llm_bridge-0.1.4/LLM_Bridge.egg-info/requires.txt

@@ -0,0 +1,15 @@
+fastapi
+httpx
+openai
+google-genai
+anthropic
+tiktoken
+pillow
+PyMuPDF
+python-docx
+openpyxl
+python-pptx
+pytest
+pytest-asyncio
+python-dotenv
+protobuf

llm_bridge-0.1.4/LLM_Bridge.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+llm_bridge
+tests

llm_bridge-0.1.4/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: LLM-Bridge
+Version: 0.1.4
+Summary: A Bridge for LLMs
+Author: windsnow1025
+Author-email: windsnow125@gmail.com
+License: MIT
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: openai
+Requires-Dist: google-genai
+Requires-Dist: anthropic
+Requires-Dist: tiktoken
+Requires-Dist: pillow
+Requires-Dist: PyMuPDF
+Requires-Dist: python-docx
+Requires-Dist: openpyxl
+Requires-Dist: python-pptx
+Requires-Dist: pytest
+Requires-Dist: pytest-asyncio
+Requires-Dist: python-dotenv
+Requires-Dist: protobuf
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

llm_bridge-0.1.4/README.md

@@ -0,0 +1,63 @@
+# LLM Bridge
+ 
+## Process
+
+1. **Message Preprocessor**: Preprocess Messages
+    1. **Message Preprocessor**: Extract Text Files to Message
+2. **Chat Client Factory**: Create Chat Client
+    1. **Model Message Converter**: Convert Message to Model
+        1. **Media Processor**: Get Model Image Content from URL
+3. **Chat Client**: Generate Response
+
+## Test
+
+```bash
+pytest ./tests/
+```
+
+## Usage
+
+See ./usage/
+
+## Build
+
+### Dependencies
+
+```bash
+pip install --upgrade setuptools wheel twine
+```
+
+### Build
+
+```bash
+python setup.py sdist bdist_wheel
+```
+
+## Publish
+
+### TestPyPI
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### PyPI
+
+```bash
+twine upload dist/*
+```
+
+## Installation
+
+### TestPyPI
+
+```bash
+pip install --index-url https://test.pypi.org/simple/ --upgrade llm_bridge
+```
+
+### PyPI
+
+```bash
+pip install --upgrade llm_bridge
+```
+

llm_bridge-0.1.4/llm_bridge/__init__.py

@@ -0,0 +1,7 @@
+from .logic.chat_generate.chat_client_factory import create_chat_client
+from .logic.chat_generate.model_message_converter.model_message_converter import *
+from .logic.message_preprocess.file_type_checker import get_file_type
+from .logic.message_preprocess.message_preprocessor import preprocess_messages
+from .type.chat_response import Citation, ChatResponse
+from .type.message import Role, Message
+from .type.serializer import serialize

llm_bridge-0.1.4/llm_bridge/client/chat_client.py

@@ -0,0 +1,8 @@
+from typing import AsyncGenerator
+
+from llm_bridge.type.chat_response import ChatResponse
+
+
+class ChatClient:
+    async def generate_response(self) -> ChatResponse | AsyncGenerator[ChatResponse, None]:
+        raise NotImplementedError

llm_bridge-0.1.4/llm_bridge/client/implementations/claude/non_stream_claude_client.py

@@ -0,0 +1,38 @@
+import logging
+import re
+
+import httpx
+from fastapi import HTTPException
+
+from llm_bridge.client.model_client.claude_client import ClaudeClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.serializer import serialize
+
+
+class NonStreamClaudeClient(ClaudeClient):
+    async def generate_response(self) -> ChatResponse:
+        try:
+            logging.info(f"messages: {self.messages}")
+            message = await self.client.messages.create(
+                model=self.model,
+                max_tokens=4096,
+                temperature=self.temperature,
+                system=self.system,
+                messages=serialize(self.messages)
+            )
+
+            content = message.content[0].text
+            return ChatResponse(text=content)
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/implementations/claude/stream_claude_client.py

@@ -0,0 +1,47 @@
+import logging
+import re
+from typing import AsyncGenerator
+
+import httpx
+from fastapi import HTTPException
+
+from llm_bridge.client.model_client.claude_client import ClaudeClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.serializer import serialize
+
+
+class StreamClaudeClient(ClaudeClient):
+    async def generate_response(self) -> AsyncGenerator[ChatResponse, None]:
+        try:
+            logging.info(f"messages: {self.messages}")
+
+            async def chunk_generator() -> AsyncGenerator[ChatResponse, None]:
+                try:
+                    async with self.client.messages.stream(
+                        model=self.model,
+                        max_tokens=4096,
+                        temperature=self.temperature,
+                        system=self.system,
+                        messages=serialize(self.messages)
+                    ) as stream:
+                        async for response_delta in stream.text_stream:
+                            yield ChatResponse(text=response_delta)
+                except Exception as e:
+                    logging.exception(e)
+                    yield ChatResponse(error=str(e))
+
+            return chunk_generator()
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/implementations/gemini/gemini_response_handler.py

@@ -0,0 +1,53 @@
+from enum import Enum
+
+from google.genai import types
+
+from llm_bridge.type.chat_response import Citation, ChatResponse
+
+
+class PrintingStatus(Enum):
+    Start = "start"
+    Thought = "thought"
+    Response = "response"
+
+
+class GeminiResponseHandler:
+    def __init__(self):
+        self.printing_status = PrintingStatus.Start
+
+    def process_gemini_response(
+            self, response: types.GenerateContentResponse
+    ) -> ChatResponse:
+        text = ""
+        display = None
+        citations = extract_citations(response)
+
+        for part in response.candidates[0].content.parts:
+            if part.thought and self.printing_status == PrintingStatus.Start:
+                text += "# Model Thought:\n\n"
+                self.printing_status = PrintingStatus.Thought
+            elif not part.thought and self.printing_status == PrintingStatus.Thought:
+                text += f"\n\n# Model Response:\n\n"
+                self.printing_status = PrintingStatus.Response
+            text += part.text
+        if grounding_metadata := response.candidates[0].grounding_metadata:
+            if search_entry_point := grounding_metadata.search_entry_point:
+                display = search_entry_point.rendered_content
+            if grounding_metadata.grounding_chunks:
+                text += "\n\n# Grounding Sources:\n"
+                for i, chunk in enumerate(grounding_metadata.grounding_chunks, start=1):
+                    if chunk.web:
+                        text += f"{i}. [{chunk.web.title}]({chunk.web.uri})\n"
+
+        return ChatResponse(text=text, display=display, citations=citations)
+
+
+def extract_citations(response: types.GenerateContentResponse) -> list[Citation]:
+    citations = []
+    if grounding_metadata := response.candidates[0].grounding_metadata:
+        if grounding_supports := grounding_metadata.grounding_supports:
+            for grounding_support in grounding_supports:
+                citation_indices = [index + 1 for index in grounding_support.grounding_chunk_indices]
+                citation_text = grounding_support.segment.text
+                citations.append(Citation(text=citation_text, indices=citation_indices))
+    return citations if citations else None

llm_bridge-0.1.4/llm_bridge/client/implementations/gemini/non_stream_gemini_client.py

@@ -0,0 +1,38 @@
+import logging
+import re
+
+import httpx
+from fastapi import HTTPException
+
+from llm_bridge.client.implementations.gemini.gemini_response_handler import *
+from llm_bridge.client.model_client.gemini_client import GeminiClient
+from llm_bridge.type.chat_response import ChatResponse
+
+
+class NonStreamGeminiClient(GeminiClient):
+    async def generate_response(self) -> ChatResponse:
+        try:
+            logging.info(f"messages: {self.messages}")
+
+            response = await self.client.aio.models.generate_content(
+                model=self.model,
+                contents=self.messages,
+                config=self.config,
+            )
+
+            gemini_response_handler = GeminiResponseHandler()
+            return gemini_response_handler.process_gemini_response(response)
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/implementations/gemini/stream_gemini_client.py

@@ -0,0 +1,56 @@
+import logging
+import re
+from typing import AsyncGenerator, AsyncIterator
+
+import httpx
+from fastapi import HTTPException
+from google.genai import types
+
+from llm_bridge.client.implementations.gemini.gemini_response_handler import GeminiResponseHandler
+from llm_bridge.client.model_client.gemini_client import GeminiClient
+from llm_bridge.type.chat_response import ChatResponse
+
+gemini_response_handler = GeminiResponseHandler()
+
+
+def process_delta(completion_delta: types.GenerateContentResponse) -> ChatResponse:
+    return gemini_response_handler.process_gemini_response(completion_delta)
+
+
+async def generate_chunk(
+        response: AsyncIterator[types.GenerateContentResponse]
+) -> AsyncGenerator[ChatResponse, None]:
+    try:
+        async for response_delta in response:
+            yield process_delta(response_delta)
+    except Exception as e:
+        logging.exception(e)
+        yield ChatResponse(error=str(e))
+
+
+class StreamGeminiClient(GeminiClient):
+    async def generate_response(self) -> AsyncGenerator[ChatResponse, None]:
+        try:
+            logging.info(f"messages: {self.messages}")
+
+            response = await self.client.aio.models.generate_content_stream(
+                model=self.model,
+                contents=self.messages,
+                config=self.config,
+            )
+
+            return generate_chunk(response)
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/implementations/gpt/non_stream_gpt_client.py

@@ -0,0 +1,47 @@
+import logging
+import re
+
+import httpx
+import openai
+from fastapi import HTTPException
+from openai import APIStatusError
+
+from llm_bridge.client.model_client.gpt_client import GPTClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.serializer import serialize
+
+
+class NonStreamGPTClient(GPTClient):
+    async def generate_response(self) -> ChatResponse:
+        try:
+            logging.info(f"messages: {self.messages}")
+            completion = await self.client.chat.completions.create(
+                messages=serialize(self.messages),
+                model=self.model,
+                temperature=self.temperature,
+                stream=False
+            )
+
+            content = completion.choices[0].message.content
+            return ChatResponse(text=content)
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except openai.BadRequestError as e:
+            status_code = e.status_code
+            text = e.message
+            raise HTTPException(status_code=status_code, detail=text)
+        except APIStatusError as e:
+            status_code = e.status_code
+            text = e.message
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/implementations/gpt/stream_gpt_client.py

@@ -0,0 +1,73 @@
+import logging
+import re
+from typing import AsyncGenerator
+
+import httpx
+import openai
+from fastapi import HTTPException
+from openai import APIStatusError, AsyncStream
+from openai.types.chat import ChatCompletionChunk
+
+from llm_bridge.client.model_client.gpt_client import GPTClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.serializer import serialize
+
+
+def process_delta(completion_delta: ChatCompletionChunk) -> str:
+    # Necessary for Azure
+    if not completion_delta.choices:
+        return ""
+
+    content_delta = completion_delta.choices[0].delta.content
+    if not content_delta:
+        content_delta = ""
+    logging.debug(f"chunk: {content_delta}")
+    return content_delta
+
+
+async def generate_chunk(
+        completion: AsyncStream[ChatCompletionChunk]
+) -> AsyncGenerator[ChatResponse, None]:
+    try:
+        async for completion_delta in completion:
+            content_delta = process_delta(completion_delta)
+            yield ChatResponse(text=content_delta)
+    except Exception as e:
+        logging.exception(e)
+        yield ChatResponse(error=str(e))
+
+
+class StreamGPTClient(GPTClient):
+    async def generate_response(self) -> AsyncGenerator[ChatResponse, None]:
+        try:
+            logging.info(f"messages: {self.messages}")
+            completion = await self.client.chat.completions.create(
+                messages=serialize(self.messages),
+                model=self.model,
+                temperature=self.temperature,
+                stream=True
+            )
+
+            return generate_chunk(completion)
+
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            text = e.response.text
+            raise HTTPException(status_code=status_code, detail=text)
+        except openai.BadRequestError as e:
+            status_code = e.status_code
+            text = e.message
+            raise HTTPException(status_code=status_code, detail=text)
+        except APIStatusError as e:
+            status_code = e.status_code
+            text = e.message
+            raise HTTPException(status_code=status_code, detail=text)
+        except Exception as e:
+            logging.exception(e)
+            match = re.search(r'\d{3}', str(e))
+            if match:
+                error_code = int(match.group(0))
+            else:
+                error_code = 500
+
+            raise HTTPException(status_code=error_code, detail=str(e))

llm_bridge-0.1.4/llm_bridge/client/model_client/claude_client.py

@@ -0,0 +1,26 @@
+from typing import AsyncGenerator
+
+import anthropic
+
+from llm_bridge.client.chat_client import ChatClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.model_message.claude_message import ClaudeMessage
+
+
+class ClaudeClient(ChatClient):
+    def __init__(
+            self,
+            model: str,
+            messages: list[ClaudeMessage],
+            temperature: float,
+            system: str,
+            client: anthropic.AsyncAnthropic,
+    ):
+        self.model = model
+        self.messages = messages
+        self.temperature = temperature
+        self.system = system
+        self.client = client
+
+    async def generate_response(self) -> ChatResponse | AsyncGenerator[ChatResponse, None]:
+        raise NotImplementedError

llm_bridge-0.1.4/llm_bridge/client/model_client/gemini_client.py

@@ -0,0 +1,27 @@
+from typing import AsyncGenerator
+
+from google import genai
+from google.genai import types
+
+from llm_bridge.client.chat_client import ChatClient
+from llm_bridge.type.chat_response import ChatResponse
+from llm_bridge.type.model_message.gemini_message import GeminiMessage
+
+
+class GeminiClient(ChatClient):
+    def __init__(
+            self,
+            model: str,
+            messages: list[GeminiMessage],
+            temperature: float,
+            client: genai.Client,
+            config: types.GenerateContentConfig,
+    ):
+        self.model = model
+        self.messages = messages
+        self.temperature = temperature
+        self.client = client
+        self.config = config
+
+    async def generate_response(self) -> ChatResponse | AsyncGenerator[ChatResponse, None]:
+        raise NotImplementedError