openrouter-provider 0.0.1__py3-none-any.whl

OpenRouterProvider/Chat_message.py

@@ -0,0 +1,134 @@
+from .LLMs import LLMModel
+
+from enum import Enum
+from PIL import Image
+import base64
+from io import BytesIO
+from dataclasses import dataclass
+
+
+class Role(Enum):
+    system = "system"
+    user = "user"
+    ai = "assistant"
+    agent = "agent"
+    tool = "tool"
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: dict
+    result: any = ""
+
+
+class Chat_message:
+    def __init__(self, text: str, images: list[Image.Image]=None, role: Role=Role.user, answerdBy: LLMModel=None, token :int=0, cost: float=0) -> None:
+        self.role = role
+        self.text = text
+        self.images = self._process_image(images=images)
+        self.token = token
+        self.cost = cost
+        self.answeredBy: LLMModel = answerdBy
+        
+        self.tool_calls: list[ToolCall] = []
+
+    def __str__(self) -> str:
+        # ANSI color codes for blue, green, and reset (to default)
+        BLUE = "\033[34m"
+        GREEN = "\033[32m"
+        RESET = "\033[0m"
+        
+        message = ""
+        
+        if self.role == Role.system:
+            message = "---------------------- System ----------------------\n"
+        elif self.role == Role.user:
+            message = BLUE + "----------------------- User -----------------------\n" + RESET
+        elif self.role == Role.ai:
+            message = GREEN + "--------------------- Assistant --------------------\n" + RESET
+        
+        # Append text and reset color formatting at the end
+        message += self.text + RESET + "\n"
+        
+        return message
+        
+    def _process_image(self, images: list):
+        """
+        Process a list of images by resizing them to maintain aspect ratio and then converting them to base64 format.
+        
+        Args:
+            images (list): A list of image objects to be processed.
+
+        Returns:
+            list: A list of base64-encoded image strings if input is not None/empty, otherwise `None`.
+        
+        Note:
+            - Images should be provided as a "list" even if there is only a single image to process.
+        """
+        if images == None:
+            return None
+
+        base64_images = []
+        for image in images:
+            if image.mode == "RGBA":
+                image = image.convert("RGB")
+            
+            image = self._resize_image_aspect_ratio(image=image)
+            image = self._convert_to_base64(image=image)
+            base64_images.append(image)
+
+        return base64_images
+        
+    def _convert_to_base64(self, image: Image) -> str:
+        """
+        Convert an image to a base64-encoded string.
+
+        Args:
+            image (Image): The image object to be converted to base64 format.
+
+        Returns:
+            str: The base64-encoded string representation of the image.
+
+        Note:
+            - The image format will default to 'JPEG' if the format is not specified.
+        """
+        buffered = BytesIO()
+        format = image.format if image.format else 'JPEG'
+        image.save(buffered, format=format)
+        img_bytes = buffered.getvalue()
+        img_base64 = base64.b64encode(img_bytes).decode('utf-8')
+        
+        return img_base64
+    
+    def _resize_image_aspect_ratio(self, image: Image, target_length=1024):
+        """
+        Resize an image to a target length while maintaining its aspect ratio.
+
+        Args:
+            image (Image): The image object to be resized.
+            target_length (int, optional): The target length for the larger dimension (default is 1024).
+
+        Returns:
+            Image: The resized image object with maintained aspect ratio.
+
+        Note:
+            - The smaller dimension is scaled proportionally based on the larger dimension to maintain aspect ratio.
+            - If the image's aspect ratio is non-square, the target_length is applied to the larger dimension.
+        """
+        
+        width, height = image.size
+        
+        if width > height:
+            new_width = target_length
+            new_height = int((target_length / width) * height)
+        else:
+            new_height = target_length
+            new_width = int((target_length / height) * width)
+
+        resized_image = image.resize((new_width, new_height))
+        
+        return resized_image
+    
+        

OpenRouterProvider/Chatbot_manager.py

@@ -0,0 +1,121 @@
+from .Chat_message import *
+from .OpenRouterProvider import *
+from .LLMs import LLMModel
+
+from dotenv import load_dotenv
+import time
+import json
+
+_base_system_prompt = """
+It's [TIME] today.
+You are an intelligent AI. You must follow the system_instruction below, which is provided by the user.
+
+<system_instruction>
+[SYSTEM_INSTRUCTION]
+</system_instruction>
+"""
+
+class Chatbot_manager:
+    def __init__(self, system_prompt:str="", tools:list[tool_model]=[]) -> None:
+        load_dotenv()
+        
+        self._memory: list[Chat_message] = []
+        self.tools: list[tool_model] = tools
+        self.set_system_prompt(prompt=system_prompt)
+        
+    def set_system_prompt(self, prompt: str):
+        m, d, y = time.localtime()[:3]
+
+        system_prompt = _base_system_prompt
+        system_prompt = system_prompt.replace("[TIME]", f"{m}/{d}/{y}")
+        system_prompt = system_prompt.replace("[SYSTEM_INSTRUCTION]", prompt)
+        
+        self._system_prompt = Chat_message(text=system_prompt, role=Role.system)
+        
+    def clear_memory(self):
+        self._memory = []
+        
+    def print_memory(self):
+        print("\n--------------------- Chatbot memory ---------------------")
+        print(f"system   : {self._system_prompt.text}")
+
+        for message in self._memory:
+            role = message.role.value
+            text = message.text.strip()
+            
+            reset_code = "\033[0m"
+            role_str = f"{role.ljust(9)}:"
+            indent = " " * len(role_str)
+            lines = text.splitlines()
+            
+            if role == "user":
+                color_code = "\033[94m"  # blue
+                if lines:
+                    print(f"{color_code}{role_str}{reset_code} {lines[0]}")
+                    for line in lines[1:]:
+                        print(f"{color_code}{indent}{reset_code} {line}")
+                else:
+                    print(f"{color_code}{role_str}{reset_code}")
+            
+            elif role == "assistant":
+                color_code = "\033[92m"  # green
+                if lines:
+                    print(f"{color_code}{role_str}{reset_code} {lines[0]}")
+                    for line in lines[1:]:
+                        print(f"{color_code}{indent}{reset_code} {line}")
+                else:
+                    print(f"{color_code}{role_str}{reset_code}")
+
+            elif role == "tool":
+                color_code = "\033[93m"  # orange
+                print(f"{color_code}{role_str}{reset_code} ", end="")
+                
+                for tool in message.tool_calls:
+                    print(f"{tool.name}({json.loads(tool.arguments)}), ", end="")
+                print()
+                
+            else:
+                color_code = "\033[0m"   # default color
+                print("Print error: The role is invalid.")
+            
+        print("----------------------------------------------------------\n")
+
+    def invoke(self, model: LLMModel, query: Chat_message, tools: list[tool_model]=[]) -> Chat_message:
+        self._memory.append(query)
+        client = OpenRouterProvider()
+        reply = client.invoke(
+            model=model,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            tools=self.tools + tools
+        )
+        reply.answeredBy = model
+        self._memory.append(reply)
+
+        if reply.tool_calls:
+            for requested_tool in reply.tool_calls:
+                args = requested_tool.arguments
+                if isinstance(args, str):
+                    args = json.loads(args)
+
+                for tool in (self.tools + tools):
+                    if tool.name == requested_tool.name:
+                        result = tool(**args)
+                        requested_tool.result = result
+                        break
+                else:
+                    print("Tool Not found", requested_tool.name)
+                    return reply
+                    
+            reply = client.invoke(
+                model=model,
+                system_prompt=self._system_prompt,
+                querys=self._memory,
+                tools=self.tools + tools
+            )
+            
+            reply.answeredBy = model
+            self._memory.append(reply)
+
+        return reply
+    

OpenRouterProvider/LLMs.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+@dataclass
+class LLMModel:
+    name: str
+    input_cost: float = 0
+    output_cost: float = 0
+
+
+# OpenAI
+gpt_4o = LLMModel(name='openai/gpt-4o', input_cost=2.5, output_cost=10.0)
+gpt_4o_mini = LLMModel(name='openai/gpt-4o-mini', input_cost=0.15, output_cost=0.60)
+gpt_4_1 = LLMModel(name='openai/gpt-4.1', input_cost=2, output_cost=8.0)
+gpt_4_1_mini = LLMModel(name='openai/gpt-4.1-mini', input_cost=0.4, output_cost=1.6)
+gpt_4_1_nano = LLMModel(name='openai/gpt-4.1-nano', input_cost=0.1, output_cost=0.4)
+o4_mini = LLMModel(name='openai/o4-mini', input_cost=1.1, output_cost=4.4)
+o4_mini_high = LLMModel(name='openai/o4-mini-high', input_cost=1.1, output_cost=4.4)
+o3 = LLMModel(name='openai/o3', input_cost=10, output_cost=40)
+
+# Anthropic
+claude_3_7_sonnet = LLMModel(name='anthropic/claude-3.7-sonnet', input_cost=3.0, output_cost=15.0)
+claude_3_7_sonnet_thinking = LLMModel(name='anthropic/claude-3.7-sonnet:thinking', input_cost=3.0, output_cost=15.0)
+claude_3_5_haiku = LLMModel(name='anthropic/claude-3.5-haiku', input_cost=0.8, output_cost=4.0)
+
+# Google
+gemini_2_0_flash = LLMModel(name='google/gemini-2.0-flash-001', input_cost=0.1, output_cost=0.4)
+gemini_2_0_flash_free = LLMModel(name='google/gemini-2.0-flash-exp:free', input_cost=0.1, output_cost=0.4)
+gemini_2_5_flash = LLMModel(name='google/gemini-2.5-flash-preview', input_cost=0.15, output_cost=0.60)
+gemini_2_5_flash_thinking = LLMModel(name='google/gemini-2.5-flash-preview:thinking', input_cost=0.15, output_cost=3.5)
+gemini_2_5_pro = LLMModel(name='google/gemini-2.5-pro-preview-03-25', input_cost=1.25, output_cost=10)
+
+# Deepseek
+deepseek_v3_free = LLMModel(name='deepseek/deepseek-chat-v3-0324:free', input_cost=0, output_cost=0)
+deepseek_v3 = LLMModel(name='deepseek/deepseek-chat-v3-0324', input_cost=0.3, output_cost=1.2)
+deepseek_r1_free = LLMModel(name='deepseek/deepseek-r1:free', input_cost=0, output_cost=0)
+deepseek_r1 = LLMModel(name='deepseek/deepseek-r1', input_cost=0.5, output_cost=2.2)
+
+# xAI
+grok_3_mini = LLMModel(name='x-ai/grok-3-mini-beta', input_cost=0.3, output_cost=0.5)
+grok_3 = LLMModel(name='x-ai/grok-3-beta', input_cost=3, output_cost=15)
+
+# Microsoft
+mai_ds_r1_free = LLMModel(name="microsoft/mai-ds-r1:free", input_cost=0, output_cost=0)
+
+# Others
+llama_4_maverick_free = LLMModel(name="meta-llama/llama-4-maverick:free", input_cost=0, output_cost=0)
+llama_4_scout = LLMModel(name="meta-llama/llama-4-scout", input_cost=0.11, output_cost=0.34)
+mistral_small_3_1_24B_free = LLMModel(name="mistralai/mistral-small-3.1-24b-instruct:free", input_cost=0, output_cost=0)

OpenRouterProvider/OpenRouterProvider.py

@@ -0,0 +1,84 @@
+from .Chat_message import *
+from .Tool import tool_model
+from .LLMs import *
+
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+
+class OpenRouterProvider:
+    def __init__(self) -> None:
+        load_dotenv()
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=os.getenv("OPENROUTER_API_KEY"),
+        )
+
+    def make_prompt(self, system_prompt: Chat_message,
+                querys: list[Chat_message]) -> list[dict]:
+        messages = [{"role": "system", "content": system_prompt.text}]
+
+        for query in querys:
+            # ----- USER -----
+            if query.role == Role.user:
+                if query.images is None:
+                    messages.append({"role": "user", "content": query.text})
+                else:
+                    content = [{"type": "text", "text": query.text}]
+                    for img in query.images[:50]:
+                        content.append(
+                            {"type": "image_url",
+                            "image_url": {"url": f"data:image/jpeg;base64,{img}"}})
+                    messages.append({"role": "user", "content": content})
+
+            # ----- ASSISTANT -----
+            elif query.role == Role.ai or query.role == Role.tool:
+                assistant_msg = {"role": "assistant"}
+                assistant_msg["content"] = query.text or None      # ← content は明示必須
+
+                # ① tool_calls を付与（あれば）
+                if query.tool_calls:
+                    assistant_msg["tool_calls"] = [
+                        {
+                            "id": str(t.id),
+                            "type": "function",
+                            "function": {
+                                "name": t.name,
+                                "arguments": t.arguments          # JSON 文字列
+                            }
+                        }
+                        for t in query.tool_calls
+                    ]
+                messages.append(assistant_msg)
+
+            # ② tool メッセージを assistant の直後に並べる
+            for t in query.tool_calls:
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": str(t.id),
+                    "content": str(t.result)                  # 実行結果（文字列）
+                })
+        return messages
+
+
+    def invoke(self, model: LLMModel, system_prompt: Chat_message, querys: list[Chat_message], tools:list[tool_model]=[]) -> Chat_message:
+        response = self.client.chat.completions.create(
+            model=model.name,
+            messages=self.make_prompt(system_prompt, querys),
+            tools=[tool.tool_definition for tool in tools],
+            extra_body={
+                "provider": {
+                    "order": ["Groq"]
+                }
+            }
+        )
+        reply = Chat_message(text=response.choices[0].message.content, role=Role.ai)
+        
+        if response.choices[0].message.tool_calls:
+            reply.role = Role.tool
+            for tool in response.choices[0].message.tool_calls:
+                reply.tool_calls.append(ToolCall(id=tool.id, name=tool.function.name, arguments=tool.function.arguments))
+                
+        return reply
+

OpenRouterProvider/Tool.py

@@ -0,0 +1,71 @@
+import inspect
+from functools import wraps
+from typing import get_type_hints, get_origin, get_args
+
+
+class tool_model:
+    def __init__(self, func):
+        self.func = func
+        self.name = func.__name__
+
+        sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+
+        type_map = {
+            int:   "integer",
+            str:   "string",
+            float: "number",
+            bool:  "boolean",
+        }
+
+        properties = {}
+        required = []
+
+        # Build JSON schema properties
+        for name, param in sig.parameters.items():
+            anno = type_hints.get(name, None)
+            origin = get_origin(anno)
+
+            if origin is list:
+                # Handle list element types
+                (elem_type,) = get_args(anno)
+                json_item_type = type_map.get(elem_type, "string")
+                schema = {
+                    "type": "array",
+                    "items": {"type": json_item_type},
+                    "description": name,
+                }
+            else:
+                # Primitive types
+                json_type = type_map.get(anno, "string")
+                schema = {
+                    "type": json_type,
+                    "description": name,
+                }
+
+            properties[name] = schema
+            if param.default is inspect._empty:
+                required.append(name)
+
+        # Attach tool definition metadata
+        self.tool_definition = {
+            "type": "function",
+            "function": {
+                "name": func.__name__,
+                "description": func.__doc__,
+                "parameters": {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required,
+                    "additionalProperties": False,
+                },
+                "strict": True,
+            },
+        }
+
+        wraps(func)(self)
+
+    def __call__(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+    
+    

openrouter_provider-0.0.1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: openrouter-provider
+Version: 0.0.1
+Summary: This is an unofficial wrapper of OpenRouter.
+Author-email: Keisuke Miyamto <aichiboyhighschool@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: annotated-types
+Requires-Dist: anyio
+Requires-Dist: certifi
+Requires-Dist: distro
+Requires-Dist: h11
+Requires-Dist: httpcore
+Requires-Dist: httpx
+Requires-Dist: idna
+Requires-Dist: jiter
+Requires-Dist: openai
+Requires-Dist: pillow
+Requires-Dist: pydantic
+Requires-Dist: pydantic_core
+Requires-Dist: python-dotenv
+Requires-Dist: sniffio
+Requires-Dist: tqdm
+Requires-Dist: typing-inspection
+Requires-Dist: typing_extensions

openrouter_provider-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OpenRouterProvider/Chat_message.py,sha256=EG6CGfe3qLdczehA6wkX9FWTEFdKteAKWprQ5VSRbbU,4259
+OpenRouterProvider/Chatbot_manager.py,sha256=NxxzbARiS6KcyCTwo26dR81Q4bv6HNueqlZF8YFOeTo,4261
+OpenRouterProvider/LLMs.py,sha256=-0ELd6fqmdDvsdaPIElRsluiK85-Y6USwvQb2b4M8TA,2607
+OpenRouterProvider/OpenRouterProvider.py,sha256=c6lFsr_4yEUNfc6UQvvp1RIfFUPD6iDd8qkaFgazxrM,3292
+OpenRouterProvider/Tool.py,sha256=QeeWOD2oaYjB9tjF-Jvcjd_G_qSUIuKwFgyh20Ne06I,2010
+openrouter_provider-0.0.1.dist-info/METADATA,sha256=B4NslzpmN4eqZaCV7YRsTt6PgwbBTffkbpizLeLR9Xc,678
+openrouter_provider-0.0.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+openrouter_provider-0.0.1.dist-info/top_level.txt,sha256=I5BMEzkQFEnEYTqOY1Ktmnp7r1rrZQyeWdclKyyyHKs,28
+openrouter_provider-0.0.1.dist-info/RECORD,,

openrouter_provider-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.3.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

openrouter_provider-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+OpenRouterProvider
+__init__