unique_toolkit 0.0.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

unique_toolkit/language_model/service.py

@@ -0,0 +1,261 @@
+import logging
+from typing import Optional, cast
+
+import unique_sdk
+
+from unique_toolkit.app.performance.async_wrapper import async_warning, to_async
+from unique_toolkit.chat.state import ChatState
+from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.language_model.infos import LanguageModelName
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessages,
+    LanguageModelResponse,
+    LanguageModelStreamResponse,
+    LanguageModelTool,
+)
+
+
+class LanguageModelService:
+    def __init__(self, state: ChatState, logger: Optional[logging.Logger] = None):
+        self.state = state
+        self.logger = logger or logging.getLogger(__name__)
+
+    _DEFAULT_COMPLETE_TIMEOUT = 240_000
+    _DEFAULT_COMPLETE_TEMPERATURE = 0.0
+
+    def complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        temperature: float = _DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = _DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+    ):
+        """
+        Calls the completion endpoint synchronously without streaming the response.
+
+        Args:
+            messages (LanguageModelMessages): The LanguageModelMessages obj to complete.
+            model_name (LanguageModelName): The model name.
+            temperature (float): The temperature value. Defaults to 0.
+            timeout (int): The timeout value in milliseconds. Defaults to 240_000.
+            tools (Optional[list[LanguageModelTool]]): The tools to use. Defaults to None.
+
+        Returns:
+            LanguageModelResponse: The LanguageModelResponse object.
+        """
+        return self._trigger_complete(
+            messages=messages,
+            model_name=model_name,
+            temperature=temperature,
+            timeout=timeout,
+            tools=tools,
+        )
+
+    @to_async
+    @async_warning
+    def async_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        temperature: float = _DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = _DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+    ):
+        """
+        Calls the completion endpoint asynchronously without streaming the response.
+
+        Args:
+            messages (LanguageModelMessages): The messages to complete.
+            model_name (LanguageModelName): The model name.
+            temperature (float): The temperature value. Defaults to 0.
+            timeout (int): The timeout value in milliseconds. Defaults to 240_000.
+            tools (Optional[list[LanguageModelTool]]): The tools to use. Defaults to None.
+
+        Returns:
+            str: The completed message content.
+        """
+        return self._trigger_complete(
+            messages=messages,
+            model_name=model_name,
+            temperature=temperature,
+            timeout=timeout,
+            tools=tools,
+        )
+
+    def _trigger_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        temperature: float,
+        timeout: int,
+        tools: Optional[list[LanguageModelTool]] = None,
+    ) -> LanguageModelResponse:
+        options = self._add_tools_to_options({}, tools)
+        messages = messages.model_dump(exclude_none=True)
+        try:
+            response = unique_sdk.ChatCompletion.create(
+                company_id=self.state.company_id,
+                # TODO change or extend types in unique_sdk
+                model=model_name.name,  # type: ignore
+                messages=cast(
+                    list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                    messages,
+                ),
+                timeout=timeout,
+                temperature=temperature,
+                options=options,  # type: ignore
+            )
+        except Exception as e:
+            self.logger.error(f"Error completing: {e}")
+            raise e
+
+        return LanguageModelResponse(**response)
+
+    def stream_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        content_chunks: list[ContentChunk] = [],
+        debug_info: dict = {},
+        temperature: float = _DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = _DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+        start_text: Optional[str] = None,
+    ):
+        """
+        Streams a completion in the chat session synchronously.
+
+        Args:
+            messages (LanguageModelMessages): The LanguageModelMessages object to stream.
+            content_chunks (list[ContentChunk]): The ContentChunks objects.
+            model_name (LanguageModelName): The language model to use for the completion.
+            debug_info (dict): The debug information. Defaults to {}.
+            temperature (float): The temperature value. Defaults to 0.25.
+            timeout (int): The timeout value in milliseconds. Defaults to 240_000.
+            tools (Optional[list[LanguageModelTool]]): The tools to use. Defaults to None.
+            start_text (Optional[str]): The start text. Defaults to None.
+
+        Returns:
+            The LanguageModelStreamResponse object once the stream has finished.
+        """
+        return self._trigger_stream_complete(
+            messages=messages,
+            content_chunks=content_chunks,
+            model_name=model_name,
+            debug_info=debug_info,
+            timeout=timeout,
+            temperature=temperature,
+            tools=tools,
+            start_text=start_text,
+        )
+
+    @to_async
+    @async_warning
+    def async_stream_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        content_chunks: list[ContentChunk] = [],
+        debug_info: dict = {},
+        temperature: float = _DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = _DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+        start_text: Optional[str] = None,
+    ):
+        """
+        Streams a completion in the chat session asynchronously.
+
+        Args:
+            messages (LanguageModelMessages): The LanguageModelMessages object to stream.
+            content_chunks (list[ContentChunk]): The content chunks.
+            model_name (LanguageModelName): The language model to use for the completion.
+            debug_info (dict): The debug information. Defaults to {}.
+            temperature (float): The temperature value. Defaults to 0.25.
+            timeout (int): The timeout value in milliseconds. Defaults to 240_000.
+            tools (Optional[list[LanguageModelTool]]): The tools to use. Defaults to None.
+            start_text (Optional[str]): The start text. Defaults to None.
+
+        Returns:
+            The LanguageModelStreamResponse object once the stream has finished.
+        """
+        return self._trigger_stream_complete(
+            messages=messages,
+            content_chunks=content_chunks,
+            model_name=model_name,
+            debug_info=debug_info,
+            timeout=timeout,
+            temperature=temperature,
+            tools=tools,
+            start_text=start_text,
+        )
+
+    def _trigger_stream_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName,
+        content_chunks: list[ContentChunk],
+        debug_info: dict,
+        timeout: int,
+        temperature: float,
+        tools: Optional[list[LanguageModelTool]] = None,
+        start_text: Optional[str] = None,
+    ) -> LanguageModelStreamResponse:
+        options = self._add_tools_to_options({}, tools)
+        search_context = [
+            unique_sdk.Integrated.SearchResult(
+                id=chunk.id,
+                chunkId=chunk.chunk_id,
+                key=chunk.key,
+                title=chunk.title,
+                url=chunk.url,
+                startPage=chunk.start_page,
+                endPage=chunk.end_page,
+                order=chunk.order,
+                object=chunk.object,
+            )  # type: ignore
+            for chunk in content_chunks
+        ]
+
+        messages = messages.model_dump(exclude_none=True)
+
+        try:
+            response = unique_sdk.Integrated.chat_stream_completion(
+                user_id=self.state.user_id,
+                company_id=self.state.company_id,
+                assistantMessageId=self.state.assistant_message_id,  # type: ignore
+                userMessageId=self.state.user_message_id,  # type: ignore
+                messages=cast(
+                    list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                    messages,
+                ),
+                chatId=self.state.chat_id,
+                searchContext=search_context,
+                # TODO change or extend types in unique_sdk
+                model=model_name.name,  # type: ignore
+                timeout=timeout,
+                temperature=temperature,
+                assistantId=self.state.assistant_id,
+                debugInfo=debug_info,
+                options=options,  # type: ignore
+                startText=start_text,
+            )
+        except Exception as e:
+            self.logger.error(f"Error streaming completion: {e}")
+            raise e
+
+        return LanguageModelStreamResponse(**response)
+
+    @staticmethod
+    def _add_tools_to_options(
+        options: dict, tools: Optional[list[LanguageModelTool]]
+    ) -> dict:
+        if tools:
+            options["tools"] = [
+                {
+                    "type": "function",
+                    "function": tool.model_dump(exclude_none=True),
+                }
+                for tool in tools
+            ]
+        return options

unique_toolkit/language_model/utils.py

@@ -0,0 +1,44 @@
+import json as j
+import re
+
+
+def convert_string_to_json(string: str):
+    """
+    Removes any json tags and converts string to json.
+
+    Args:
+        string: The string to convert to json.
+
+    Returns:
+        dict: The json object.
+
+    Raises:
+        ValueError: If the string cannot be converted to json.
+    """
+    cleaned_result = find_last_json_object(string)
+    if not cleaned_result:
+        raise ValueError("Could not find a valid json object in the string.")
+    try:
+        json = j.loads(cleaned_result)
+    except j.JSONDecodeError:
+        raise ValueError("Could not convert the string to JSON.")
+    return json
+
+
+def find_last_json_object(text: str) -> str | None:
+    """
+    Finds the last json object in a string.
+
+    Args:
+        text: The text to search for the last json object.
+
+    Returns:
+        str | None: The last json object as a string or None if no json object was found.
+    """
+
+    pattern = r"\{(?:[^{}]|\{[^{}]*\})*\}"
+    matches = re.findall(pattern, text)
+    if matches:
+        return matches[-1]
+    else:
+        return None

unique_toolkit-0.5.1.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: unique_toolkit
+Version: 0.5.1
+Summary: 
+License: MIT
+Author: Martin Fadler
+Author-email: martin.fadler@unique.ch
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy (>=2.0.1,<3.0.0)
+Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: regex (>=2024.5.15,<2025.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
+Requires-Dist: typing-extensions (>=4.9.0,<5.0.0)
+Requires-Dist: unique-sdk (>=0.8.10,<0.9.0)
+Description-Content-Type: text/markdown
+
+# Unique Toolkit
+
+This package provides highlevel abstractions and methods on top of `unique_sdk` to ease application development for the Unique Platform. 
+
+The Toolkit is structured along the following domains:
+- `unique_toolkit.chat`
+- `unique_toolkit.content`
+- `unique_toolkit.embedding`
+- `unique_toolkit.language_model`
+
+Each domain comprises a service class (in `service.py`) which encapsulates the basic functionalities to interact with the domain entities, the schemas 
+(in `schemas.py`) used in the service and required for interacting with the service functions, utility functions (in `utils.py`) which give additional
+functionality to interact with the domain entities (all domains except embedding) and other domain specific functionalities which are explained in the respective domain documentation.
+
+In addition, the `unique_toolkit.app` module provides functions to initialize apps that interact with the Unique platform. It also includes some utility functions to run async tasks in parallel (async webserver and app implementation required).
+
+## Changelog
+
+See the [CHANGELOG.md](https://github.com/Unique-AG/ai/blob/main/unique_toolkit/CHANGELOG.md) file for details on changes and version history.
+
+# Domains
+
+## App
+
+The `unique_toolkit.app` module encompasses functions for initializing and securing apps that will interact with the Unique platform.
+
+- `init_logging.py` can be used to initalize the logger either with unique dictConfig or an any other dictConfig.
+- `init_sdk.py` can be used to initialize the sdk using the correct env variables and retrieving the endpoint secret.
+- `schemas.py` contains the Event schema which can be used to parse and validate the unique.chat.external-module.chosen event.
+- `verification.py` can be used to verify the endpoint secret and construct the event.
+
+## Chat
+
+The `unique_toolkit.chat` module encompasses all chat related functionality.
+
+- `state.py` comprises the ChatState which is used to store the current state of the chat interaction and the user information.
+- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
+- `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
+- `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt. 
+
+## Content
+
+The `unique_toolkit.content` module encompasses all content related functionality. Content can be any type of textual data that is stored in the Knowledgebase on the Unique platform. During the ingestion of the content, the content is parsed, split in chunks, indexed, and stored in the database.
+
+- `service.py` comprises the ContentService and provides an interface to interact with the content, e.g., search content, search content chunks, upload and download content.
+- `schemas.py` comprises all relevant schemas, e.g., Content and ContentChunk, used in the ContentService.
+- `utils.py` comprise utility functions to manipulate Content and ContentChunk objects, e.g., sort_content_chunks and merge_content_chunks.
+
+## Embedding
+
+The `unique_toolkit.embedding` module encompasses all embedding related functionality. Embeddings are used to represent textual data in a high-dimensional space. The embeddings can be used to calculate the similarity between two texts, for instance.
+
+- `service.py` encompasses the EmbeddingService and provides an interface to interact with the embeddings, e.g., embed text and calculate the similarity between two texts.
+- `schemas.py` comprises all relevant schemas, e.g., Embeddings, used in the EmbeddingService.
+
+## Language Model
+
+The `unique_toolkit.language_model` module encompasses all language model related functionality and information on the different language models deployed through the 
+Unique platform.
+
+- `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_16K) to get the information on the specific language model like the name, version, token limits or retirement date.
+- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete or stream_complete. 
+- `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
+- `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.
+
+# Development instructions
+
+1. Install poetry on your system (through `brew` or `pipx`).
+
+2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.
+
+3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.
+
+4. Then finally run `poetry install` to install the package and all dependencies.
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.5.1] - 2024-07-23
+- correct documentation
+
+## [0.5.0] - 2024-07-23
+### Added
+- Added `unique_toolkit.app` module with the following components:
+  - `init_logging.py` for initializing the logger.
+  - `init_sdk.py` for initializing the SDK with environment variables.
+  - `schemas.py` containing the Event schema.
+  - `verification.py` for verifying the endpoint secret and constructing the event.
+
+- Added `unique_toolkit.chat` module with the following components:
+  - `state.py` containing the `ChatState` class.
+  - `service.py` containing the `ChatService` class for managing chat interactions.
+  - `schemas.py` containing relevant schemas such as `ChatMessage`.
+  - `utils.py` with utility functions for chat interactions.
+
+- Added `unique_toolkit.content` module with the following components:
+  - `service.py` containing the `ContentService` class for interacting with content.
+  - `schemas.py` containing relevant schemas such as `Content` and `ContentChunk`.
+  - `utils.py` with utility functions for manipulating content objects.
+
+- Added `unique_toolkit.embedding` module with the following components:
+  - `service.py` containing the `EmbeddingService` class for working with embeddings.
+  - `schemas.py` containing relevant schemas such as `Embeddings`.
+
+- Added `unique_toolkit.language_model` module with the following components:
+  - `infos.py` containing information on language models deployed on the Unique platform.
+  - `service.py` containing the `LanguageModelService` class for interacting with language models.
+  - `schemas.py` containing relevant schemas such as `LanguageModelResponse`.
+  - `utils.py` with utility functions for parsing language model output.
+
+## [0.0.2] - 2024-07-10
+- Initial release of `unique_toolkit`.

unique_toolkit-0.5.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+unique_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3h23gQ,678
+unique_toolkit/app/init_sdk.py,sha256=Nv4Now4pMfM0AgRhbtatLpm_39rKxn0WmRLwmPhRl-8,1285
+unique_toolkit/app/performance/async_executor.py,sha256=ImekDRWkFeXuIYFnCpSJAqE0RP-liK-5R8_buZGqYaE,6435
+unique_toolkit/app/performance/async_wrapper.py,sha256=Xli5zH9RFdbBJnlBQS_kP7TGqXhPNou5WKst4FLWzGo,770
+unique_toolkit/app/schemas.py,sha256=2PYnMmH3eBzmlIhHHir44WN5YHGYlUWEpdY7fyQkK8E,1098
+unique_toolkit/app/verification.py,sha256=UZqTHg3PX_QxMjeLH_BVBYoMVqMnMpeMoqvyTBKDqj8,1996
+unique_toolkit/chat/schemas.py,sha256=aEXf0tX1ljHjb73jy1pilUKivrvle54iDLiyQ093u7c,794
+unique_toolkit/chat/service.py,sha256=zxMoOMKlLJNwtRAO8GCpX9tGwVUsbgHWEPWztGe6htw,12300
+unique_toolkit/chat/state.py,sha256=IljPSqbzQq9TMD9cnbkII8k4eTtkyYOGzRe-DuR-Nic,1831
+unique_toolkit/chat/utils.py,sha256=ihm-wQykBWhB4liR3LnwPVPt_qGW6ETq21Mw4HY0THE,854
+unique_toolkit/content/schemas.py,sha256=u3b0R6bIEjbI4zGMoBRi-bdZy_SeRKtMRi8PKW6yMZ4,1969
+unique_toolkit/content/service.py,sha256=Y7MsKoQnuDAp3cAtNawzmH_rzfSKOaib8jjA3HsflTs,11372
+unique_toolkit/content/utils.py,sha256=x3ABo8ZCRm3YJAQwDtrr82z77DmW4Mei7KCIITjP0fk,6897
+unique_toolkit/embedding/schemas.py,sha256=1GvKCaSk4jixzVQ2PKq8yDqwGEVY_hWclYtoAr6CC2g,96
+unique_toolkit/embedding/service.py,sha256=IjBag3koSSeoQTo9836t0K5tkTbu0otvytVWnYQJHw4,2403
+unique_toolkit/language_model/infos.py,sha256=NhAkeW7PyusSIHCMvwRikLlzGG4tOXSLf_Fnq7V9rNE,8881
+unique_toolkit/language_model/schemas.py,sha256=kTGSGT3ygrH3guQELOWpxN4MTgEPuudi-CTvRu-zCcI,4377
+unique_toolkit/language_model/service.py,sha256=VHixKmi6-BP-StDQdomS-J-EWKIhHvDjNCi5zrP3mpM,9749
+unique_toolkit/language_model/utils.py,sha256=WBPj1XKkDgxy_-T8HCZvsfkkSzj_1w4UZzNmyvdbBLY,1081
+unique_toolkit-0.5.1.dist-info/LICENSE,sha256=bIeCWCYuoUU_MzNdg48-ubJSVm7qxakaRbzTiJ5uxrs,1065
+unique_toolkit-0.5.1.dist-info/METADATA,sha256=4_lwdj3XE4JxtY2fPtHdZKboLC8jUwQyLFPSKMqMjXY,8062
+unique_toolkit-0.5.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.5.1.dist-info/RECORD,,

unique_toolkit-0.0.2.dist-info/METADATA

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: unique_toolkit
-Version: 0.0.2
-Summary: 
-License: MIT
-Author: Unique Data Science
-Author-email: datascience@unique.ch
-Requires-Python: >=3.11,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: pydantic (>=2.8.2,<3.0.0)
-Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
-Requires-Dist: typing-extensions (>=4.9.0,<5.0.0)
-Requires-Dist: unique-sdk (>=0.8.10,<0.9.0)
-Description-Content-Type: text/markdown
-
-# Unique Tool Kit
-
-This package provides highlevel abstractions and methods on top of `unique_sdk` to ease application development for the Unique Platform.
-
-
-# Development instructions
-
-1. Install poetry on your system (through `brew` or `pipx`).
-
-2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.
-
-3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.
-
-4. Then finally run `poetry install` to install the package and all dependencies.
-

unique_toolkit-0.0.2.dist-info/RECORD

@@ -1,5 +0,0 @@
-unique_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-unique_toolkit-0.0.2.dist-info/LICENSE,sha256=bIeCWCYuoUU_MzNdg48-ubJSVm7qxakaRbzTiJ5uxrs,1065
-unique_toolkit-0.0.2.dist-info/METADATA,sha256=caF_T0teqWqTgctUU9qI2F2CtxlU3TKYuBQyGlEzkwk,1233
-unique_toolkit-0.0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.0.2.dist-info/RECORD,,