unique_toolkit 0.7.9__py3-none-any.whl → 1.33.3__py3-none-any.whl

unique_toolkit/embedding/service.py

@@ -1,8 +1,11 @@
+from typing import overload
+
 from typing_extensions import deprecated
 
 from unique_toolkit._common._base_service import BaseService
 from unique_toolkit._common.validate_required_values import validate_required_values
 from unique_toolkit.app.schemas import BaseEvent, Event
+from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.embedding.constants import DEFAULT_TIMEOUT
 from unique_toolkit.embedding.functions import embed_texts, embed_texts_async
 from unique_toolkit.embedding.schemas import Embeddings
@@ -11,10 +14,23 @@ from unique_toolkit.embedding.schemas import Embeddings
 class EmbeddingService(BaseService):
     """
     Provides methods to interact with the Embedding service.
+    """
 
-    Attributes:
-        company_id (str | None): The company ID.
-        user_id (str | None): The user ID.
+    @deprecated(
+        "Use __init__ with company_id and user_id instead or use the classmethod `from_event`"
+    )
+    @overload
+    def __init__(self, event: Event | BaseEvent): ...
+
+    """
+        Initialize the EmbeddingService with an event (deprecated)
+    """
+
+    @overload
+    def __init__(self, *, company_id: str, user_id: str): ...
+
+    """
+        Initialize the EmbeddingService with a company_id and user_id.
     """
 
     def __init__(
@@ -25,12 +41,35 @@ class EmbeddingService(BaseService):
     ):
         self._event = event
         if event:
-            self.company_id = event.company_id
-            self.user_id = event.user_id
+            self._company_id: str = event.company_id
+            self._user_id: str = event.user_id
         else:
             [company_id, user_id] = validate_required_values([company_id, user_id])
-            self.company_id = company_id
-            self.user_id = user_id
+            self._company_id: str = company_id
+            self._user_id: str = user_id
+
+    @classmethod
+    def from_event(cls, event: Event | BaseEvent):
+        """
+        Initialize the EmbeddingService with an event.
+        """
+        return cls(company_id=event.company_id, user_id=event.user_id)
+
+    @classmethod
+    def from_settings(cls, settings: UniqueSettings | str | None = None):
+        """
+        Initialize the EmbeddingService with a settings object.
+        """
+
+        if settings is None:
+            settings = UniqueSettings.from_env_auto_with_sdk_init()
+        elif isinstance(settings, str):
+            settings = UniqueSettings.from_env_auto_with_sdk_init(filename=settings)
+
+        return cls(
+            company_id=settings.auth.company_id.get_secret_value(),
+            user_id=settings.auth.user_id.get_secret_value(),
+        )
 
     @property
     @deprecated(
@@ -45,6 +84,58 @@ class EmbeddingService(BaseService):
         """
         return self._event
 
+    @property
+    @deprecated(
+        "The company_id property is deprecated and will be removed in a future version."
+    )
+    def company_id(self) -> str | None:
+        """
+        Get the company identifier (deprecated).
+
+        Returns:
+            str | None: The company identifier.
+        """
+        return self._company_id
+
+    @company_id.setter
+    @deprecated(
+        "The company_id setter is deprecated and will be removed in a future version."
+    )
+    def company_id(self, value: str) -> None:
+        """
+        Set the company identifier (deprecated).
+
+        Args:
+            value (str | None): The company identifier.
+        """
+        self._company_id = value
+
+    @property
+    @deprecated(
+        "The user_id property is deprecated and will be removed in a future version."
+    )
+    def user_id(self) -> str | None:
+        """
+        Get the user identifier (deprecated).
+
+        Returns:
+            str | None: The user identifier.
+        """
+        return self._user_id
+
+    @user_id.setter
+    @deprecated(
+        "The user_id setter is deprecated and will be removed in a future version."
+    )
+    def user_id(self, value: str) -> None:
+        """
+        Set the user identifier (deprecated).
+
+        Args:
+            value (str | None): The user identifier.
+        """
+        self._user_id = value
+
     def embed_texts(
         self,
         texts: list[str],
@@ -54,7 +145,7 @@ class EmbeddingService(BaseService):
         Embed text.
 
         Args:
-            text (str): The text to embed.
+            texts (list[str]): The texts to embed.
             timeout (int): The timeout in milliseconds. Defaults to 600000.
 
         Returns:
@@ -64,8 +155,8 @@ class EmbeddingService(BaseService):
             Exception: If an error occurs.
         """
         return embed_texts(
-            user_id=self.user_id,
-            company_id=self.company_id,
+            user_id=self._user_id,
+            company_id=self._company_id,
             texts=texts,
             timeout=timeout,
         )
@@ -89,8 +180,8 @@ class EmbeddingService(BaseService):
             Exception: If an error occurs.
         """
         return await embed_texts_async(
-            user_id=self.user_id,
-            company_id=self.company_id,
+            user_id=self._user_id,
+            company_id=self._company_id,
             texts=texts,
             timeout=timeout,
         )

unique_toolkit/framework_utilities/__init__.py

@@ -0,0 +1 @@
+"""Framework utilities for integrating with external frameworks."""

unique_toolkit/framework_utilities/langchain/__init__.py

@@ -0,0 +1,10 @@
+"""Langchain framework utilities."""
+
+try:
+    from .client import LangchainNotInstalledError, get_langchain_client
+
+    __all__ = ["get_langchain_client", "LangchainNotInstalledError"]
+except (ImportError, Exception):
+    # If langchain is not installed, don't export anything
+    # This handles both ImportError and LangchainNotInstalledError
+    __all__ = []

unique_toolkit/framework_utilities/langchain/client.py

@@ -0,0 +1,71 @@
+import importlib.util
+import logging
+
+from typing_extensions import deprecated
+
+from unique_toolkit.app.unique_settings import UniqueSettings
+from unique_toolkit.framework_utilities.utils import get_default_headers
+
+logger = logging.getLogger("toolkit.framework_utilities.langchain")
+
+
+class LangchainNotInstalledError(ImportError):
+    """Raised when langchain-openai package is not installed but functionality requiring it is accessed."""
+
+    def __init__(self):
+        super().__init__(
+            "langchain-openai package is not installed. Install it with 'poetry install --with langchain'."
+        )
+
+
+if importlib.util.find_spec("langchain_openai") is not None:
+    from langchain_openai import ChatOpenAI
+else:
+    raise LangchainNotInstalledError()
+
+
+def get_langchain_client(
+    *,
+    unique_settings: UniqueSettings | None = None,
+    model: str = "AZURE_GPT_4o_2024_0806",
+    additional_headers: dict[str, str] | None = None,
+) -> ChatOpenAI:
+    """Get a Langchain ChatOpenAI client instance.
+
+    Args:
+        unique_settings: UniqueSettings instance
+
+    Returns:
+        ChatOpenAI client instance
+
+    Raises:
+        LangchainNotInstalledError: If langchain-openai package is not installed
+    """
+    if unique_settings is None:
+        unique_settings = UniqueSettings.from_env_auto()
+
+    default_headers = get_default_headers(unique_settings.app, unique_settings.auth)
+    if additional_headers is not None:
+        default_headers.update(additional_headers)
+
+    return ChatOpenAI(
+        base_url=unique_settings.api.openai_proxy_url(),
+        default_headers=default_headers,
+        model=model,
+        api_key=unique_settings.app.key,
+    )
+
+
+@deprecated("Use get_langchain_client instead")
+def get_client(
+    unique_settings: UniqueSettings | None = None, model: str = "AZURE_GPT_4o_2024_0806"
+) -> ChatOpenAI:
+    """Get a Langchain ChatOpenAI client instance.
+
+    Args:
+        unique_settings: UniqueSettings instance
+
+    Returns:
+        ChatOpenAI client instance
+    """
+    return get_client(unique_settings, model)

unique_toolkit/framework_utilities/langchain/history.py

@@ -0,0 +1,19 @@
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+
+from unique_toolkit.chat import ChatMessage as UniqueMessage
+from unique_toolkit.chat import ChatMessageRole as UniqueRole
+
+
+def unique_history_to_langchain_history(
+    unique_history: list[UniqueMessage],
+) -> list[BaseMessage]:
+    history = []
+    for m in unique_history:
+        if m.role == UniqueRole.ASSISTANT:
+            history.append(AIMessage(content=m.content or ""))
+        elif m.role == UniqueRole.USER:
+            history.append(HumanMessage(content=m.content or ""))
+        else:
+            raise Exception("Unknown message role.")
+
+    return history

unique_toolkit/framework_utilities/openai/__init__.py

@@ -0,0 +1,6 @@
+"""OpenAI framework utilities."""
+
+from .client import get_async_openai_client, get_openai_client
+from .message_builder import OpenAIMessageBuilder
+
+__all__ = ["get_openai_client", "OpenAIMessageBuilder", "get_async_openai_client"]

unique_toolkit/framework_utilities/openai/client.py

@@ -0,0 +1,84 @@
+import importlib.util
+import logging
+
+from unique_toolkit.app.unique_settings import UniqueSettings
+from unique_toolkit.framework_utilities.utils import get_default_headers
+
+logger = logging.getLogger("toolkit.framework_utilities.openai")
+
+
+class OpenAINotInstalledError(ImportError):
+    """Raised when OpenAI package is not installed but functionality requiring it is accessed."""
+
+    def __init__(self):
+        super().__init__(
+            "OpenAI package is not installed. Install it with 'poetry install --with openai'."
+        )
+
+
+if importlib.util.find_spec("openai") is not None:
+    from openai import AsyncOpenAI, OpenAI
+else:
+    raise OpenAINotInstalledError()
+
+
+def get_openai_client(
+    *,
+    unique_settings: UniqueSettings | None = None,
+    additional_headers: dict[str, str] | None = None,
+) -> OpenAI:
+    """Get an OpenAI client instance.
+
+    Args:
+        unique_settings (UniqueSettings | None): Optional UniqueSettings instance
+        additional_headers (dict[str, str] | None): Optional additional headers to add to the request
+
+    Returns:
+        OpenAI client instance
+
+    Raises:
+        OpenAINotInstalledError: If OpenAI package is not installed
+    """
+    if unique_settings is None:
+        unique_settings = UniqueSettings.from_env_auto()
+
+    default_headers = get_default_headers(unique_settings.app, unique_settings.auth)
+    if additional_headers is not None:
+        default_headers.update(additional_headers)
+
+    return OpenAI(
+        api_key="dummy_key",
+        base_url=unique_settings.api.openai_proxy_url(),
+        default_headers=default_headers,
+    )
+
+
+def get_async_openai_client(
+    *,
+    unique_settings: UniqueSettings | None = None,
+    additional_headers: dict[str, str] | None = None,
+) -> AsyncOpenAI:
+    """Get an async OpenAI client instance.
+
+    Args:
+        unique_settings: Optional UniqueSettings instance
+
+    Returns:
+        AsyncOpenAI client instance
+
+    Raises:
+        OpenAINotInstalledError: If OpenAI package is not installed
+    """
+    if unique_settings is None:
+        unique_settings = UniqueSettings.from_env_auto()
+
+    default_headers = get_default_headers(unique_settings.app, unique_settings.auth)
+
+    if additional_headers is not None:
+        default_headers.update(additional_headers)
+
+    return AsyncOpenAI(
+        api_key="dummy_key",
+        base_url=unique_settings.api.openai_proxy_url(),
+        default_headers=default_headers,
+    )

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,
 )