unique_toolkit 0.0.1__py3-none-any.whl

unique_toolkit/__init__.py

@@ -0,0 +1,3 @@
+from .observability.log_config import load_logging_config  # noqa: F401
+from .sdk.init import init_sdk  # noqa: F401
+from .security.verify import verify_signature_and_construct_event  # noqa: F401

unique_toolkit/chat/__init__.py

@@ -0,0 +1,3 @@
+from .messages import AIMessage, AIMessageList, AIMessageRole  # noqa: F401
+from .service import ChatService  # noqa: F401
+from .state import ChatState  # noqa: F401

unique_toolkit/chat/messages.py

@@ -0,0 +1,24 @@
+from enum import StrEnum
+from typing import List
+
+from pydantic import BaseModel, RootModel
+
+
+class AIMessageRole(StrEnum):
+    USER = "user"
+    SYSTEM = "system"
+
+
+class AIMessage(BaseModel):
+    role: AIMessageRole
+    content: str
+
+
+class AIMessageList(RootModel):
+    root: List[AIMessage]
+
+    def __iter__(self):
+        return iter(self.root)
+
+    def __getitem__(self, item):
+        return self.root[item]

unique_toolkit/chat/service.py

@@ -0,0 +1,182 @@
+import unique_sdk
+from unique_sdk.utils.chat_history import load_history
+
+from unique_toolkit.performance.async_wrapper import to_async
+
+from .state import ChatState
+
+
+class ChatService:
+    """
+    Provides all functionalities to manage the chat session.
+
+    Attributes:
+        state (ChatState): The chat state.
+    """
+
+    def __init__(self, state: ChatState):
+        self.state = state
+
+    def modify_assistant_message(
+        self,
+        *,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ) -> None:
+        """
+        Modifies a message in the chat session synchronously.
+
+        Args:
+            text (str): The new text for the message.
+            references (Optional[list[dict[str, Any]]], optional): list of references. Defaults to None.
+            debug_info (Optional[dict[str, Any]]], optional): Debug information. Defaults to None.
+        """
+        self._trigger_modify_assistant_message(text, references, debug_info)
+
+    @to_async
+    def async_modify_assistant_message(
+        self,
+        *,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ) -> None:
+        """
+        Modifies a message in the chat session asynchronously.
+
+        Args:
+            text (str): The new text for the message.
+            references (Optional[list[dict[str, Any]]], optional): list of references. Defaults to None.
+            debug_info (Optional[dict[str, Any]]], optional): Debug information. Defaults to None.
+        """
+        self._trigger_modify_assistant_message(text, references, debug_info)
+
+    def get_history(
+        self,
+        *,
+        max_tokens: int,
+        percent_of_max_tokens: float,
+        max_messages: int,
+    ):
+        """
+        Loads the chat history for the chat session synchronously.
+
+        Args:
+            max_tokens (int): The maximum number of tokens to load.
+            percent_of_max_tokens (float): The percentage of the maximum tokens to load.
+            max_messages (int): The maximum number of messages to load.
+
+        Returns:
+            list[dict[str, Any]]: The chat history.
+        """
+        return self._trigger_load_history(
+            max_tokens, percent_of_max_tokens, max_messages
+        )
+
+    @to_async
+    def async_get_history(
+        self,
+        *,
+        max_tokens: int,
+        percent_of_max_tokens: float,
+        max_messages: int,
+    ):
+        """
+        Loads the chat history for the chat session asynchronously.
+
+        Args:
+            max_tokens (int): The maximum number of tokens to load.
+            percent_of_max_tokens (float): The percentage of the maximum tokens to load.
+            max_messages (int): The maximum number of messages to load.
+
+        Returns:
+            list[dict[str, Any]]: The chat history.
+        """
+        return self._trigger_load_history(
+            max_tokens, percent_of_max_tokens, max_messages
+        )
+
+    def create_assistant_message(
+        self,
+        *,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ):
+        """
+        Creates a message in the chat session synchronously.
+
+        Args:
+            text (str): The text for the message.
+            references (Optional[list[dict[str, Any]]], optional): list of references. Defaults to None.
+            debug_info (Optional[dict[str, Any]]], optional): Debug information. Defaults to None.
+        """
+        return self._trigger_create_assistant_message(text, references, debug_info)
+
+    @to_async
+    def async_create_assistant_message(
+        self,
+        *,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ):
+        """
+        Creates a message in the chat session asynchronously.
+
+        Args:
+            text (str): The text for the message.
+            references (Optional[list[dict[str, Any]]], optional): list of references. Defaults to None.
+            debug_info (Optional[dict[str, Any]]], optional): Debug information. Defaults to None.
+        """
+        return self._trigger_create_assistant_message(text, references, debug_info)
+
+    def _trigger_modify_assistant_message(
+        self,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ) -> None:
+        unique_sdk.Message.modify(
+            user_id=self.state.user_id,
+            company_id=self.state.company_id,
+            id=self.state.assistant_message_id,
+            chatId=self.state.chat_id,
+            text=text,
+            references=references or [],
+            debugInfo=debug_info or {},
+        )
+
+    def _trigger_load_history(
+        self,
+        max_tokens: int,
+        percent_of_max_tokens: float,
+        max_messages: int,
+    ):
+        return load_history(
+            self.state.user_id,
+            self.state.company_id,
+            self.state.chat_id,
+            max_tokens,
+            percent_of_max_tokens,
+            max_messages,
+        )
+
+    # TODO throws error at the moment
+    def _trigger_create_assistant_message(
+        self,
+        text: str,
+        references: list = [],
+        debug_info: dict = {},
+    ):
+        return unique_sdk.Message.create(
+            user_id=self.state.user_id,
+            company_id=self.state.company_id,
+            chatId=self.state.chat_id,
+            assistantId=self.state.assistant_id,
+            text=text,
+            role="ASSISTANT",
+            references=references,
+            debugInfo=debug_info,
+        )

unique_toolkit/chat/state.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from typing import Self
+
+from unique_toolkit.event.schema import Event
+
+
+@dataclass
+class ChatState:
+    """
+    Represents the state of the chat session.
+
+    Attributes:
+        company_id (str): The company ID.
+        user_id (str): The user ID.
+        chat_id (str): The chat ID.
+        user_message_text (str): The user message text.
+        user_message_id (str): The user message ID.
+        assistant_message_id (str): The assistant message ID.
+    """
+
+    company_id: str
+    user_id: str
+    assistant_id: str = ""
+    chat_id: str = ""
+    user_message_text: str = ""
+    user_message_id: str = ""
+    assistant_message_id: str = ""
+
+    @classmethod
+    def from_event(cls, event: Event) -> Self:
+        """
+        Creates a ChatState instance from an event dictionary.
+
+        Args:
+            event (dict): The event dictionary.
+
+        Returns:
+            ChatState: The ChatState instance.
+        """
+        # Chat only flag
+        return cls(
+            user_id=event.user_id,
+            chat_id=event.payload.chat_id,
+            company_id=event.company_id,
+            user_message_text=event.payload.user_message.text,
+            user_message_id=event.payload.user_message.id,
+            assistant_message_id=event.payload.assistant_message.id,
+        )

unique_toolkit/event/__init__.py

@@ -0,0 +1 @@
+from .schema import AssistantMessage, Event, Payload, UserMessage  # noqa: F401

unique_toolkit/event/constants.py

@@ -0,0 +1 @@
+EXTERNAL_MODULE_EVENT_NAME = "unique.chat.external-module.chosen"

unique_toolkit/event/schema.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+from humps import camelize
+from pydantic import BaseModel, ConfigDict
+
+# set config to convert camelCase to snake_case
+model_config = ConfigDict(alias_generator=camelize, populate_by_name=True)
+
+
+class UserMessage(BaseModel):
+    model_config = model_config
+
+    id: str
+    text: str
+    created_at: str
+
+
+class AssistantMessage(BaseModel):
+    model_config = model_config
+
+    id: str
+    created_at: str
+
+
+class Payload(BaseModel):
+    model_config = model_config
+
+    name: str
+    description: str
+    configuration: dict[str, Any]
+    chat_id: str
+    assistant_id: str
+    user_message: UserMessage
+    assistant_message: AssistantMessage
+    text: str | None = None
+
+
+class Event(BaseModel):
+    model_config = model_config
+
+    id: str
+    version: str
+    event: str
+    created_at: int
+    user_id: str
+    company_id: str
+    payload: Payload

unique_toolkit/llm/__init__.py

@@ -0,0 +1,2 @@
+from .models import LLMModelInfo, LLMModelName, get_llm_model_info  # noqa: F401
+from .service import LLMService  # noqa: F401

unique_toolkit/llm/json_parser.py

@@ -0,0 +1,21 @@
+import json
+import re
+
+
+def convert_to_json(result: str):
+    """
+    Removes any json tags and converts string to json.
+    """
+    cleaned_result = find_last_json_object(result)
+    if not cleaned_result:
+        raise ValueError("Could not find a valid json object in the result.")
+    return json.loads(cleaned_result)
+
+
+def find_last_json_object(text) -> str | None:
+    pattern = r"\{(?:[^{}]|\{[^{}]*\})*\}"
+    matches = re.findall(pattern, text)
+    if matches:
+        return matches[-1]
+    else:
+        return None

unique_toolkit/llm/models.py

@@ -0,0 +1,37 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class LLMModelName(StrEnum):
+    AZURE_GPT_35_TURBO_0613 = "AZURE_GPT_35_TURBO_0613"
+    AZURE_GPT_35_TURBO = "AZURE_GPT_35_TURBO"
+    AZURE_GPT_35_TURBO_16K = "AZURE_GPT_35_TURBO_16K"
+    AZURE_GPT_4_0613 = "AZURE_GPT_4_0613"
+    AZURE_GPT_4_TURBO_1106 = "AZURE_GPT_4_TURBO_1106"
+    AZURE_GPT_4_VISION_PREVIEW = "AZURE_GPT_4_VISION_PREVIEW"
+    AZURE_GPT_4_32K_0613 = "AZURE_GPT_4_32K_0613"
+    AZURE_GPT_4_TURBO_2024_0409 = "AZURE_GPT_4_TURBO_2024_0409"
+
+
+class LLMModelInfo(BaseModel):
+    name: LLMModelName
+    max_tokens: int
+
+
+llm_token_limit_map = {
+    LLMModelName.AZURE_GPT_35_TURBO_0613: 3000,
+    LLMModelName.AZURE_GPT_35_TURBO: 3000,
+    LLMModelName.AZURE_GPT_35_TURBO_16K: 14000,
+    LLMModelName.AZURE_GPT_4_0613: 7000,
+    LLMModelName.AZURE_GPT_4_TURBO_1106: 7000,
+    LLMModelName.AZURE_GPT_4_VISION_PREVIEW: 7000,
+    LLMModelName.AZURE_GPT_4_32K_0613: 30000,
+    LLMModelName.AZURE_GPT_4_TURBO_2024_0409: 7000,
+}
+
+
+def get_llm_model_info(model_name: LLMModelName) -> LLMModelInfo:
+    if model_name not in llm_token_limit_map:
+        raise ValueError(f"Model {model_name} not found.")
+    return LLMModelInfo(name=model_name, max_tokens=llm_token_limit_map[model_name])

unique_toolkit/llm/service.py

@@ -0,0 +1,163 @@
+import unique_sdk
+
+from unique_toolkit.chat.state import ChatState
+from unique_toolkit.performance.async_wrapper import to_async
+
+from .models import LLMModelName
+
+
+class LLMService:
+    def __init__(self, state: ChatState):
+        self.state = state
+
+    def stream_complete(
+        self,
+        *,
+        messages: list,
+        model_name: LLMModelName,
+        search_contexts: list = [],
+        debug_info: dict = {},
+        timeout: int = 100_000,
+        temperature: float = 0.25,
+    ):
+        """
+        Streams a completion in the chat session synchronously.
+
+        Args:
+            messages (list): The messages to stream.
+            search_contexts (list): The search context.
+            model_name (LLMModelName): The language model to use for the completion.
+            debug_info (dict): The debug information.
+            timeout (int, optional): The timeout value in milliseconds. Defaults to 100_000.
+            temperature (float, optional): The temperature value for the completion. Defaults to 0.25.
+
+        Returns:
+            A generator yielding streamed completion chunks.
+        """
+        return self._trigger_stream_complete(
+            messages,
+            search_contexts,
+            model_name.name,
+            debug_info,
+            timeout,
+            temperature,
+        )
+
+    @to_async
+    def async_stream_complete(
+        self,
+        *,
+        messages: list,
+        model_name: LLMModelName,
+        search_contexts: list = [],
+        debug_info: dict = {},
+        timeout: int = 100_000,
+        temperature: float = 0.25,
+    ):
+        """
+        Streams a completion in the chat session asynchronously.
+
+        Args:
+            messages (list[dict[str, str]]): The messages to stream.
+            search_contexts (list): The search context.
+            debug_info (dict): The debug information.
+            model_name (LLMModelName): The language model to use for the completion.
+            timeout (int, optional): The timeout value in milliseconds. Defaults to 100_000.
+            temperature (float, optional): The temperature value for the completion. Defaults to 0.25.
+
+        Returns:
+            A generator yielding streamed completion chunks.
+        """
+        return self._trigger_stream_complete(
+            messages, search_contexts, model_name, debug_info, timeout, temperature
+        )
+
+    def complete(
+        self,
+        *,
+        messages: list,
+        model_name: LLMModelName,
+        temperature: float = 0,
+        timeout: int = 240000,
+    ) -> str:
+        """
+        Calls the completion endpoint synchronously without streaming the response.
+
+        Args:
+            messages (list[dict[str, str]]): The messages to complete.
+            model_name (LLMModelName): The model name.
+            temperature (float, optional): The temperature value. Defaults to 0.
+            timeout (int, optional): The timeout value in milliseconds. Defaults to 240000.
+
+        Returns:
+            str: The completed message content.
+        """
+        return self._trigger_complete(messages, model_name, temperature, timeout)
+
+    @to_async
+    def async_complete(
+        self,
+        *,
+        messages: list,
+        model_name: LLMModelName,
+        temperature: float = 0,
+        timeout: int = 240000,
+    ) -> str:
+        """
+        Calls the completion endpoint asynchronously without streaming the response.
+
+        Args:
+            messages (list[dict[str, str]]): The messages to complete.
+            model_name (LLMModelName): The model name.
+            temperature (float, optional): The temperature value. Defaults to 0.
+            timeout (int, optional): The timeout value in milliseconds. Defaults to 240000.
+
+        Returns:
+            str: The completed message content.
+        """
+        return self._trigger_complete(
+            messages,
+            model_name.name,
+            temperature,
+            timeout,
+        )
+
+    def _trigger_stream_complete(
+        self,
+        messages: list,
+        search_contexts: list,
+        model_name: str,
+        debug_info: dict,
+        timeout: int,
+        temperature: float,
+    ):
+        return unique_sdk.Integrated.chat_stream_completion(
+            user_id=self.state.user_id,
+            company_id=self.state.company_id,
+            assistantMessageId=self.state.assistant_message_id,
+            userMessageId=self.state.user_message_id,
+            messages=messages,
+            chatId=self.state.chat_id,
+            searchContext=search_contexts,
+            debugInfo=debug_info,
+            model=model_name,  # type: ignore
+            timeout=timeout,
+            temperature=temperature,
+            assistantId=self.state.assistant_id,
+        )
+
+    def _trigger_complete(
+        self,
+        messages: list,
+        model_name: str,
+        temperature: float,
+        timeout: int,
+    ) -> str:
+        result = unique_sdk.ChatCompletion.create(
+            company_id=self.state.company_id,
+            model=model_name,  # type: ignore
+            messages=messages,
+            timeout=timeout,
+            temperature=temperature,
+        )
+        return result.choices[-1]["message"]["content"]

unique_toolkit/observability/log_config.py

@@ -0,0 +1,31 @@
+from logging import Formatter
+from logging.config import dictConfig
+from time import gmtime
+
+
+class UTCFormatter(Formatter):
+    converter = gmtime
+
+
+log_config = {
+    "version": 1,
+    "root": {"level": "DEBUG", "handlers": ["console"]},
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "level": "DEBUG",
+            "formatter": "utc",
+        },
+        "formatters": {
+            "utc": {
+                "()": UTCFormatter,
+                "format": "%(asctime)s: %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            },
+        },
+    },
+}
+
+
+def load_logging_config():
+    return dictConfig(log_config)

unique_toolkit/performance/__init__.py

@@ -0,0 +1 @@
+from .async_wrapper import to_async  # noqa: F401

unique_toolkit/performance/async_executor.py

@@ -0,0 +1,159 @@
+import asyncio
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from math import ceil
+from typing import Awaitable, Sequence, TypeVar, Union
+
+from quart import Quart
+
+T = TypeVar("T")
+Result = Union[T, BaseException]
+
+
+class AsyncExecutor:
+    def __init__(self, app_instance: Quart) -> None:
+        self.app = app_instance
+
+    async def run_async_tasks(
+        self,
+        tasks: Sequence[Awaitable[T]],
+        max_tasks: int,
+    ) -> list[Result]:
+        """
+        Executes the given async tasks within one thread non-blocking and returns the results.
+
+        Args:
+        tasks (list[Awaitable[T]]): list of async callables to execute in parallel.
+        max_tasks (int): Maximum number of tasks for the asyncio Semaphore.
+
+        Returns:
+        list[Result]: list of results from the executed tasks.
+        """
+
+        async def logging_wrapper(task: Awaitable[T], task_id: int) -> Result:
+            thread = threading.current_thread()
+            start_time = time.time()
+
+            self.app.logger.info(
+                f"Thread {thread.name} (ID: {thread.ident}) starting task {task_id}"
+            )
+
+            try:
+                async with self.app.app_context():
+                    result = await task
+                return result
+            except Exception as e:
+                self.app.logger.error(
+                    f"Thread {thread.name} (ID: {thread.ident}) - Task {task_id} failed with error: {e}"
+                )
+                return e
+            finally:
+                end_time = time.time()
+                duration = end_time - start_time
+                self.app.logger.debug(
+                    f"Thread {thread.name} (ID: {thread.ident}) - Task {task_id} finished in {duration:.2f} seconds"
+                )
+
+        sem = asyncio.Semaphore(max_tasks)
+
+        async def sem_task(task: Awaitable[T], task_id: int) -> Result:
+            async with sem:
+                return await logging_wrapper(task, task_id)
+
+        wrapped_tasks: list[Awaitable[Result]] = [
+            sem_task(task, i) for i, task in enumerate(tasks)
+        ]
+
+        results: list[Result] = await asyncio.gather(
+            *wrapped_tasks, return_exceptions=True
+        )
+
+        return results
+
+    async def run_async_tasks_in_threads(
+        self,
+        tasks: Sequence[Awaitable[T]],
+        max_threads: int,
+        max_tasks: int,
+    ) -> list[Result[T]]:
+        """
+        Executes the given async tasks in parallel threads and returns the results.
+
+        Args:
+        tasks (list[Awaitable[T]]): list of async callables to execute in parallel.
+        max_threads (int): Maximum number of threads.
+        max_tasks (int): Maximum number of tasks per thread run in parallel.
+
+        Returns:
+        list[Result]: list of results from the executed tasks.
+        """
+
+        async def run_in_thread(task_chunk: list[Awaitable[T]]) -> list[Result]:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            async with self.app.app_context():
+                return await self.run_async_tasks(task_chunk, max_tasks)
+
+        def thread_worker(
+            task_chunk: list[Awaitable[T]], chunk_id: int
+        ) -> list[Result]:
+            thread = threading.current_thread()
+            self.app.logger.info(
+                f"Thread {thread.name} (ID: {thread.ident}) starting chunk {chunk_id} with {len(task_chunk)} tasks"
+            )
+
+            start_time = time.time()
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                results = loop.run_until_complete(run_in_thread(task_chunk))
+                end_time = time.time()
+                duration = end_time - start_time
+                self.app.logger.info(
+                    f"Thread {thread.name} (ID: {thread.ident}) finished chunk {chunk_id} in {duration:.2f} seconds"
+                )
+                return results
+            except Exception as e:
+                self.app.logger.error(
+                    f"Thread {thread.name} (ID: {thread.ident}) encountered an error in chunk {chunk_id}: {str(e)}"
+                )
+                raise
+            finally:
+                loop.close()
+
+        start_time = time.time()
+        # Calculate the number of tasks per thread
+        tasks_per_thread: int = ceil(len(tasks) / max_threads)
+
+        # Split tasks into chunks
+        task_chunks: list[Sequence[Awaitable[T]]] = [
+            tasks[i : i + tasks_per_thread]
+            for i in range(0, len(tasks), tasks_per_thread)
+        ]
+
+        self.app.logger.info(
+            f"Splitting {len(tasks)} tasks into {len(task_chunks)} chunks across {max_threads} threads"
+        )
+
+        # Use ThreadPoolExecutor to manage threads
+        with ThreadPoolExecutor(max_workers=max_threads) as executor:
+            # Submit each chunk of tasks to a thread
+            future_results: list[list[Result]] = list(
+                executor.map(
+                    thread_worker,
+                    task_chunks,
+                    range(len(task_chunks)),  # chunk_id
+                )
+            )
+
+        # Flatten the results from all threads
+        results: list[Result] = [item for sublist in future_results for item in sublist]
+        end_time = time.time()
+        duration = end_time - start_time
+        self.app.logger.info(
+            f"All threads completed. Total results: {len(results)}. Duration: {duration:.2f} seconds"
+        )
+
+        return results

unique_toolkit/performance/async_wrapper.py

@@ -0,0 +1,13 @@
+import asyncio
+from functools import wraps
+from typing import Any, Callable, Coroutine, TypeVar
+
+T = TypeVar("T")
+
+
+def to_async(func: Callable[..., T]) -> Callable[..., Coroutine[Any, Any, T]]:
+    @wraps(func)
+    async def wrapper(*args, **kwargs) -> T:
+        return await asyncio.to_thread(func, *args, **kwargs)
+
+    return wrapper

unique_toolkit/sdk/init.py

@@ -0,0 +1,19 @@
+import os
+
+import unique_sdk
+
+
+def init_sdk():
+    """Initializes the SDK."""
+    unique_sdk.api_base = os.environ.get("API_BASE")  # Required
+
+    # Optional if being run locally
+    unique_sdk.api_key = os.environ.get(
+        "API_KEY", "dummy"
+    )  # Optional if being run locally
+    unique_sdk.app_id = os.environ.get(
+        "APP_ID", "dummy"
+    )  # Optional if being run locally
+    endpoint_secret = os.environ.get("ENDPOINT_SECRET", None)
+
+    return endpoint_secret

unique_toolkit/search/service.py

@@ -0,0 +1,118 @@
+from typing import Literal
+
+import unique_sdk
+from unique_sdk import Content
+
+from unique_toolkit.chat.state import ChatState
+from unique_toolkit.performance.async_wrapper import to_async
+
+
+class SearchService:
+    def __init__(self, state: ChatState):
+        self.state = state
+
+    def search(
+        self,
+        *,
+        search_string: str,
+        search_type: Literal["VECTOR", "COMBINED"],
+        limit: int,
+        scope_ids: list[str] = [],
+    ):
+        """
+        Performs a synchronous search in the knowledge base.
+
+        Args:
+            search_string (str): The search string.
+            search_type (Literal["VECTOR", "COMBINED"]): The type of search to perform.
+            limit (int): The maximum number of results to return.
+
+        Returns:
+            The search results.
+        """
+        return self._trigger_search(search_string, search_type, limit, scope_ids)
+
+    @to_async
+    def async_search(
+        self,
+        *,
+        search_string: str,
+        search_type: Literal["VECTOR", "COMBINED"],
+        limit: int,
+        scope_ids: list[str] = [],
+    ):
+        """
+        Performs an asynchronous search in the knowledge base.
+
+        Args:
+            search_string (str): The search string.
+            search_type (Literal["VECTOR", "COMBINED"]): The type of search to perform.
+            limit (int): The maximum number of results to return.
+
+        Returns:
+            The search results.
+        """
+        return self._trigger_search(search_string, search_type, limit, scope_ids)
+
+    def _trigger_search(
+        self,
+        search_string: str,
+        search_type: Literal["VECTOR", "COMBINED"],
+        limit: int,
+        scope_ids: list[str] = [],
+    ):
+        scope_ids = scope_ids or self.state.scope_ids or []
+        return unique_sdk.Search.create(
+            user_id=self.state.user_id,
+            company_id=self.state.company_id,
+            chatId=self.state.chat_id,
+            searchString=search_string,
+            searchType=search_type,
+            scopeIds=scope_ids,
+            limit=limit,
+            chatOnly=self.state.chat_only,
+        )
+
+    def search_content(
+        self,
+        *,
+        where: dict,
+    ) -> list[Content]:
+        """
+        Performs a search in the knowledge base by filter.
+
+        Args:
+            where (dict): The search criteria.
+
+        Returns:
+            The search results.
+        """
+        return self._trigger_search_content(where)
+
+    @to_async
+    def async_search_content(
+        self,
+        *,
+        where: dict,
+    ) -> list[Content]:
+        """
+        Performs an asynchronous search in the knowledge base by filter.
+
+        Args:
+            where (dict): The search criteria.
+
+        Returns:
+            The search results.
+        """
+        return self._trigger_search_content(where)
+
+    def _trigger_search_content(
+        self,
+        where: dict,
+    ) -> list[Content]:
+        return unique_sdk.Content.search(
+            user_id=self.state.user_id,
+            company_id=self.state.company_id,
+            chatId=self.state.chat_id,
+            where=where,  # type: ignore
+        )

unique_toolkit/security/verify.py

@@ -0,0 +1,29 @@
+from http import HTTPStatus
+
+import unique_sdk
+
+from unique_toolkit.event.schema import Event
+
+
+def verify_signature_and_construct_event(
+    headers, payload: bytes, endpoint_secret: str, logger
+) -> Event:
+    sig_header = headers.get("X-Unique-Signature")
+    timestamp = headers.get("X-Unique-Created-At")
+
+    if not sig_header or not timestamp:
+        logger.error("⚠️  Webhook signature or timestamp headers missing.")
+        return False, HTTPStatus.BAD_REQUEST
+
+    try:
+        event = unique_sdk.Webhook.construct_event(
+            payload,
+            sig_header,
+            timestamp,
+            endpoint_secret,
+        )
+        logger.info("✅  Webhook signature verification successful.")
+        return Event(**event)
+    except unique_sdk.SignatureVerificationError as e:
+        logger.error("⚠️  Webhook signature verification failed. " + str(e))
+        return False, HTTPStatus.BAD_REQUEST

unique_toolkit-0.0.1.dist-info/LICENSE

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

unique_toolkit-0.0.1.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.1
+Name: unique_toolkit
+Version: 0.0.1
+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 abstarctions 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.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+unique_toolkit/__init__.py,sha256=vObIHz3Vte5K6tlrytiNQQ1uqhibwnhSzB5WIt9cyIs,197
+unique_toolkit/chat/__init__.py,sha256=TocIEJrMO5_xJB4ehFhslqoxOsV2oiLlglUdIWVLa-s,166
+unique_toolkit/chat/messages.py,sha256=IuYPz8PoK6HyFsYigtfYkfz2wB8zhDJyjryWYC2D7k4,416
+unique_toolkit/chat/service.py,sha256=UigC5-1wdQYoWLfzAU7h8hl_SB05YSCOTrxhU7dgMG4,5511
+unique_toolkit/chat/state.py,sha256=7N9vsMl4mu1mbtFqg61T6-42UgnkXmLwhVfIwVnm6tc,1327
+unique_toolkit/event/__init__.py,sha256=fqfQeanYjxLFGsrX97Ti3HpzLRCE3kDUlMBVXEvzr0s,80
+unique_toolkit/event/constants.py,sha256=hwdCgSKBAZQYZSl1nFkP1yWiw6GBI7KbcNJrdxFxVm8,66
+unique_toolkit/event/schema.py,sha256=sT0gtJN2LT0ormP7HfVot11Oub1YlzfBCKFj3G0Or4w,879
+unique_toolkit/llm/__init__.py,sha256=3hT7PhdHnEQaqILJ6gGSe0cpkWEDMgZ_PHw1Q01W0e4,127
+unique_toolkit/llm/json_parser.py,sha256=sHTe6_VuqqwrC1xCg9ud3VOukEzVSoj0Uce_sv7GEYE,528
+unique_toolkit/llm/models.py,sha256=Gt691uSL74e3bdIm4UhAcp3Nw-jafnqJSgKdzhLJKww,1254
+unique_toolkit/llm/service.py,sha256=UXXMo7MKcj7fbDKlv0gk2J00ClL1F7n0_6uiwOLSXoY,5226
+unique_toolkit/observability/log_config.py,sha256=mfIu4cX95AiqOCdh2iW3iLoXtwrIrkPCXRtG_zYMhSs,679
+unique_toolkit/performance/__init__.py,sha256=TYPrsYdxXhhom12ub0dzvR6dHtFdjnF-P506LYitj8Y,50
+unique_toolkit/performance/async_executor.py,sha256=8N8GQn-MQN-8fX8DAbbYt7s2_91G0nchFQ25i9lIxsE,5555
+unique_toolkit/performance/async_wrapper.py,sha256=MB3cgqcl-Y7Ltc9a_l8bkhfOGrds1lUtici17b9dGuQ,339
+unique_toolkit/sdk/init.py,sha256=UQLbHxUjN_dttkiUznfJclYPHNVwANdf8w6H4SKs9Y4,482
+unique_toolkit/search/service.py,sha256=hGzfFAdBt9Y5pwPHXTEmzid4FnEsXu9DiSzpw5gPv1Y,3167
+unique_toolkit/security/verify.py,sha256=RxBw-gnWUsvqZT6rAt5Eq0vaR0rDY8AqUOTBZmQUItE,927
+unique_toolkit-0.0.1.dist-info/LICENSE,sha256=nojs8Z8soUMb9wg1sAUZdJxyhzRGrUIXFeq0_I-zejo,1065
+unique_toolkit-0.0.1.dist-info/METADATA,sha256=klnJs0EqSKVW0wz384xzI0PU-gaAbTIkb0EVHpLukhQ,1233
+unique_toolkit-0.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.0.1.dist-info/RECORD,,

unique_toolkit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any