unique_toolkit 0.7.7__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/framework_utilities/openai/message_builder.py

@@ -0,0 +1,229 @@
+import base64
+import mimetypes
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Self, overload
+
+from openai.types.chat.chat_completion_assistant_message_param import (
+    Audio,
+    ChatCompletionAssistantMessageParam,
+    ContentArrayOfContentPart,
+    FunctionCall,
+)
+from openai.types.chat.chat_completion_content_part_image_param import (
+    ChatCompletionContentPartImageParam,
+    ImageURL,
+)
+from openai.types.chat.chat_completion_content_part_param import (
+    ChatCompletionContentPartParam,
+)
+from openai.types.chat.chat_completion_content_part_text_param import (
+    ChatCompletionContentPartTextParam,
+)
+from openai.types.chat.chat_completion_developer_message_param import (
+    ChatCompletionDeveloperMessageParam,
+)
+from openai.types.chat.chat_completion_function_message_param import (
+    ChatCompletionFunctionMessageParam,
+)
+from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    ChatCompletionMessageToolCallParam,
+)
+from openai.types.chat.chat_completion_system_message_param import (
+    ChatCompletionSystemMessageParam,
+)
+from openai.types.chat.chat_completion_tool_message_param import (
+    ChatCompletionToolMessageParam,
+)
+from openai.types.chat.chat_completion_user_message_param import (
+    ChatCompletionUserMessageParam,
+)
+from typing_extensions import Literal
+
+
+class OpenAIUserMessageBuilder:
+    def __init__(
+        self,
+    ) -> None:
+        self._messages: list[ChatCompletionContentPartParam] = []
+
+    def append_text(self, content: str) -> Self:
+        part = ChatCompletionContentPartTextParam(
+            type="text",
+            text=content,
+        )
+        self._messages.append(part)
+        return self
+
+    @overload
+    def append_image(
+        self, *, url: str, detail: Literal["auto", "low", "high"] = "auto"
+    ) -> Self: ...
+
+    @overload
+    def append_image(
+        self, *, path: Path, detail: Literal["auto", "low", "high"] = "auto"
+    ) -> Self: ...
+
+    @overload
+    def append_image(
+        self,
+        *,
+        content: bytes,
+        mime_type: str,
+        detail: Literal["auto", "low", "high"] = "auto",
+    ) -> Self: ...
+
+    def append_image(
+        self,
+        *,
+        url: str | None = None,
+        path: Path | None = None,
+        content: bytes | None = None,
+        mime_type: str | None = None,
+        detail: Literal["auto", "low", "high"] = "auto",
+    ) -> Self:
+        if url is None and path is None and (content is None or mime_type is None):
+            raise ValueError("Either url or path must be provided")
+
+        if path is not None:
+            # Read image file and encode as base64 data URI
+            image_data = path.read_bytes()
+            base64_image = base64.b64encode(image_data).decode("utf-8")
+            mime_type = mimetypes.guess_type(str(path))[0] or "image/jpeg"
+            url = f"data:{mime_type};base64,{base64_image}"
+
+        if content is not None and mime_type is not None:
+            base64_image = base64.b64encode(content).decode("utf-8")
+            url = f"data:{mime_type};base64,{base64_image}"
+
+        image_url = ImageURL(url=url or "", detail=detail)
+        part = ChatCompletionContentPartImageParam(
+            type="image_url",
+            image_url=image_url,
+        )
+        self._messages.append(part)
+        return self
+
+    @property
+    def user_message(self) -> ChatCompletionUserMessageParam:
+        return ChatCompletionUserMessageParam(
+            content=self._messages,
+            role="user",
+        )
+
+    @property
+    def iterable_content(self) -> Iterable[ChatCompletionContentPartParam]:
+        return self._messages
+
+
+class OpenAIMessageBuilder:
+    def __init__(
+        self,
+        messages: list[ChatCompletionMessageParam] | None = None,
+    ) -> None:
+        self._messages: list[ChatCompletionMessageParam] = []
+        if messages:
+            self._messages = messages
+
+    @classmethod
+    def from_messages(cls, messages: list[ChatCompletionMessageParam]) -> Self:
+        builder = cls()
+        builder._messages = messages.copy()
+        return builder
+
+    def append(self, message: ChatCompletionMessageParam):
+        self._messages.append(message)
+
+    def system_message_append(
+        self,
+        content: str | Iterable[ChatCompletionContentPartTextParam],
+        name: str = "system",
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionSystemMessageParam(
+                content=content,
+                role="system",
+            ),
+        )
+        return self
+
+    def user_message_append(
+        self,
+        content: str | Iterable[ChatCompletionContentPartParam],
+        name: str = "user",
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionUserMessageParam(
+                content=content,
+                role="user",
+            ),
+        )
+        return self
+
+    def assistant_message_append(
+        self,
+        content: str | Iterable[ContentArrayOfContentPart] | None = None,
+        name: str = "assistant",
+        audio: Audio | None = None,
+        function_call: FunctionCall | None = None,
+        refusal: str | None = None,
+        tool_calls: Iterable[ChatCompletionMessageToolCallParam] | None = None,
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionAssistantMessageParam(
+                content=content,
+                role="assistant",
+                audio=audio,
+                function_call=function_call,
+                refusal=refusal,
+                tool_calls=tool_calls or [],
+            ),
+        )
+        return self
+
+    def developper_message_append(
+        self,
+        content: str | Iterable[ChatCompletionContentPartTextParam],
+        name: str = "developer",
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionDeveloperMessageParam(
+                content=content,
+                role="developer",
+            ),
+        )
+        return self
+
+    def function_message_append(
+        self,
+        content: str | None,
+        name: str = "function",
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionFunctionMessageParam(
+                content=content,
+                role="function",
+                name=name,
+            ),
+        )
+        return self
+
+    def tool_message_append(
+        self,
+        content: str | Iterable[ChatCompletionContentPartTextParam],
+        tool_call_id: str,
+    ) -> Self:
+        self._messages.append(
+            ChatCompletionToolMessageParam(
+                content=content,
+                role="tool",
+                tool_call_id=tool_call_id,
+            ),
+        )
+        return self
+
+    @property
+    def messages(self) -> list[ChatCompletionMessageParam]:
+        return self._messages

unique_toolkit/framework_utilities/utils.py

@@ -0,0 +1,23 @@
+from unique_toolkit.app.unique_settings import UniqueApp, UniqueAuth
+
+
+def auth_headers(auth_settings: UniqueAuth) -> dict[str, str]:
+    return {
+        "x-user-id": auth_settings.user_id.get_secret_value(),
+        "x-company-id": auth_settings.company_id.get_secret_value(),
+    }
+
+
+def app_headers(app_settings: UniqueApp) -> dict[str, str]:
+    return {
+        "x-app-id": app_settings.id.get_secret_value(),
+        "Authorization": f"Bearer {app_settings.key.get_secret_value()}",
+    }
+
+
+def get_default_headers(app_settings: UniqueApp, auth_settings: UniqueAuth):
+    default_headers = {}
+    default_headers.update(app_headers(app_settings))
+    default_headers.update(auth_headers(auth_settings))
+    default_headers["x-api-version"] = "2023-12-06"
+    return default_headers

unique_toolkit/language_model/__init__.py

@@ -43,6 +43,9 @@ from .schemas import (
 from .schemas import (
     LanguageModelTool as LanguageModelTool,
 )
+from .schemas import (
+    LanguageModelToolDescription as LanguageModelToolDescription,
+)
 from .schemas import (
     LanguageModelToolMessage as LanguageModelToolMessage,
 )

unique_toolkit/language_model/builder.py

@@ -1,4 +1,4 @@
-from typing_extensions import Self
+from typing import Any, Self
 
 from unique_toolkit.language_model import (
     LanguageModelAssistantMessage,
@@ -17,6 +17,10 @@ class MessagesBuilder:
     def __init__(self):
         self.messages: list[LanguageModelMessage] = []
 
+    def append(self, message: LanguageModelMessage) -> Self:
+        self.messages.append(message)
+        return self
+
     def message_append(self, role: LanguageModelMessageRole, content: str):
         message = LanguageModelMessage(role=role, content=content)
         self.messages.append(message)
@@ -35,23 +39,33 @@ class MessagesBuilder:
         return self  # Return self to allow method chaining
 
     def image_message_append(
-        self, content: str, images: list[str], role=LanguageModelMessageRole.USER
+        self,
+        content: str,
+        images: list[str],
+        role: LanguageModelMessageRole = LanguageModelMessageRole.USER,
     ) -> Self:
+        final_content: list[dict[str, Any]] = [{"type": "text", "text": content}]
+        final_content.extend(
+            [
+                {
+                    "type": "image_url",
+                    "imageUrl": {"url": image},
+                }
+                for image in images
+            ],
+        )
+
         message = LanguageModelMessage(
             role=role,
-            content=[
-                {"type": "text", "text": content},
-                *[
-                    {"type": "image_url", "imageUrl": {"url": image}}
-                    for image in images
-                ],
-            ],
+            content=final_content,
         )
         self.messages.append(message)
         return self
 
     def assistant_message_append(
-        self, content: str, tool_calls: list[LanguageModelFunction] | None = None
+        self,
+        content: str,
+        tool_calls: list[LanguageModelFunction] | None = None,
     ) -> Self:
         """Appends an assistant message to the messages list."""
         message = LanguageModelAssistantMessage(content=content)
@@ -70,7 +84,9 @@ class MessagesBuilder:
     def tool_message_append(self, name: str, tool_call_id: str, content: str) -> Self:
         """Appends a tool message to the messages list."""
         message = LanguageModelToolMessage(
-            name=name, tool_call_id=tool_call_id, content=content
+            name=name,
+            tool_call_id=tool_call_id,
+            content=content,
         )
         self.messages.append(message)
         return self

unique_toolkit/language_model/default_language_model.py

@@ -0,0 +1,3 @@
+from unique_toolkit.language_model.infos import LanguageModelName
+
+DEFAULT_GPT_4o = LanguageModelName.AZURE_GPT_4o_2024_1120