unique_toolkit 0.8.0__tar.gz → 0.8.2__tar.gz

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.8.2] - 2025-08-05
+- Implement overloads for services for clearer dev experience
+- Proper typing for SSE event handling
+- Enhanced unique settings. Expose usage of default values in logs
+- SDK Initialization from unique settings
+- Add utilities for to run llm/agent flows for devs
+
+## [0.8.1] - 2025-08-05
+- Bump SDK version to support the latest features.
+
 ## [0.8.0] - 2025-08-04
 - Add MCP support
 

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.0
+Version: 0.8.2
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -113,6 +113,17 @@ 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.8.2] - 2025-08-05
+- Implement overloads for services for clearer dev experience
+- Proper typing for SSE event handling
+- Enhanced unique settings. Expose usage of default values in logs
+- SDK Initialization from unique settings
+- Add utilities for to run llm/agent flows for devs
+
+## [0.8.1] - 2025-08-05
+- Bump SDK version to support the latest features.
+
 ## [0.8.0] - 2025-08-04
 - Add MCP support
 

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "0.8.0"
+version = "0.8.2"
 description = ""
 authors = [
     "Martin Fadler <martin.fadler@unique.ch>",

unique_toolkit-0.8.2/unique_toolkit/app/dev_util.py

@@ -0,0 +1,146 @@
+import asyncio
+import json
+from logging import getLogger
+from pathlib import Path
+from typing import (
+    Awaitable,
+    Callable,
+    Generator,
+    TypeVar,
+)
+
+from sseclient import SSEClient
+
+from unique_toolkit.app import BaseEvent, ChatEvent, EventName
+from unique_toolkit.app.init_sdk import init_unique_sdk
+from unique_toolkit.app.unique_settings import UniqueSettings
+
+T = TypeVar("T", bound=BaseEvent)
+
+LOGGER = getLogger(__name__)
+
+
+def get_event_name_from_event_class(event_class: type[T]) -> EventName | None:
+    if event_class is ChatEvent:
+        return EventName.EXTERNAL_MODULE_CHOSEN
+
+    return None
+
+
+def get_sse_client(
+    unique_settings: UniqueSettings,
+    subscriptions: list[str],
+) -> SSEClient:
+    headers = {
+        "Authorization": f"Bearer {unique_settings.app.key.get_secret_value()}",
+        "x-app-id": unique_settings.app.id.get_secret_value(),
+        "x-company-id": unique_settings.auth.company_id.get_secret_value(),
+        "x-user-id": unique_settings.auth.user_id.get_secret_value(),
+        "x-api-version": unique_settings.api.version,
+    }
+    return SSEClient(url=unique_settings.api.sse_url(subscriptions), headers=headers)
+
+
+def get_event_generator(
+    unique_settings: UniqueSettings, event_type: type[T]
+) -> Generator[T, None, None]:
+    """
+    Generator that yields only events of the specified type from an SSE stream.
+
+    Args:
+        sse_client: The SSE client to read events from
+        event_type: The event class type to filter for
+
+    Yields:
+        Events matching the specified type
+    """
+    event_name = get_event_name_from_event_class(event_type)
+    if (
+        event_name is None
+        or not issubclass(event_type, BaseEvent)
+        or event_type is BaseEvent
+    ):
+        raise ValueError(f"Event model {event_type} is not a valid event model")
+
+    subscription = event_name.value
+
+    for sse_event in get_sse_client(unique_settings, [subscription]):
+        try:
+            payload = json.loads(sse_event.data)
+            parsed_event = event_type.model_validate(payload)
+            if parsed_event is None:
+                continue
+
+            yield parsed_event
+
+        except Exception as e:
+            LOGGER.error(f"Could not parse SSE event data as JSON: {e}")
+            continue
+
+
+def run_demo_with_sse_client(
+    unique_settings: UniqueSettings,
+    handler: Callable[[BaseEvent], Awaitable[None] | None],
+    event_type: type[BaseEvent],
+) -> None:
+    """
+    Run a demo with an SSE client using sync handler.
+
+    Args:
+        unique_settings: The unique settings to use for the SSE client
+        handler: The sync handler to use for the SSE client
+        event_type: The type of event to use for the SSE client
+    """
+
+    event_name = get_event_name_from_event_class(event_type)
+    if event_name is None:
+        return
+
+    init_unique_sdk(unique_settings=unique_settings)
+    is_async_handler = asyncio.iscoroutinefunction(handler)
+
+    for event in get_event_generator(unique_settings, event_type):
+        if is_async_handler:
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(handler(event))
+        else:
+            handler(event)
+
+
+def load_event(file_path: Path, event_type: type[BaseEvent]) -> BaseEvent:
+    with file_path.open("r") as file:
+        event = json.load(file)
+
+    return event_type.model_validate(event)
+
+
+def run_demo_with_with_saved_event(
+    unique_settings: UniqueSettings,
+    handler: Callable[[BaseEvent], Awaitable[None] | None],
+    event_type: type[BaseEvent],
+    file_path: Path,
+) -> None:
+    """
+    Run a demo with an SSE client.
+
+    Note: event_type is the type of event that the handler expects.
+
+    Args:
+        unique_settings: The unique settings to use for the SSE client
+        handler: The handler to use for the SSE client
+        event_type: The type of event to use for the SSE client
+    """
+    init_unique_sdk(unique_settings=unique_settings)
+
+    event_name = get_event_name_from_event_class(event_type)
+    if event_name is None:
+        return
+
+    event = load_event(file_path, event_type)
+    if event is None:
+        raise ValueError(f"Event not found in {file_path}")
+
+    if asyncio.iscoroutinefunction(handler):
+        asyncio.run(handler(event))
+    else:
+        handler(event)

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/app/init_sdk.py

@@ -1,6 +1,11 @@
 import os
+from pathlib import Path
+from typing import overload
 
 import unique_sdk
+from typing_extensions import deprecated
+
+from unique_toolkit.app.unique_settings import UniqueSettings
 
 
 def get_env(var_name, default=None, strict=False):
@@ -24,12 +29,38 @@ def get_env(var_name, default=None, strict=False):
     return val or default
 
 
-def init_sdk(strict_all_vars=False):
+@overload
+def init_unique_sdk(*, env_file: Path | None = None): ...
+
+
+@overload
+def init_unique_sdk(*, unique_settings: UniqueSettings): ...
+
+
+def init_unique_sdk(
+    *, unique_settings: UniqueSettings | None = None, env_file: Path | None = None
+):
+    if unique_settings:
+        unique_sdk.api_key = unique_settings.app.key.get_secret_value()
+        unique_sdk.app_id = unique_settings.app.id.get_secret_value()
+        unique_sdk.api_base = unique_settings.api.sdk_url()
+    elif env_file:
+        unique_settings = UniqueSettings.from_env(env_file=env_file)
+        unique_sdk.api_key = unique_settings.app.key.get_secret_value()
+        unique_sdk.app_id = unique_settings.app.id.get_secret_value()
+        unique_sdk.api_base = unique_settings.api.sdk_url()
+
+
+@deprecated("Use init_unique_sdk instead")
+def init_sdk(
+    strict_all_vars: bool = False,
+):
     """Initialize the SDK.
 
     Args:
         strict_all_vars (bool, optional): This method raises a ValueError if strict and no value is found in the environment. Defaults to False.
     """
+
     unique_sdk.api_key = get_env("API_KEY", default="dummy", strict=strict_all_vars)
     unique_sdk.app_id = get_env("APP_ID", default="dummy", strict=strict_all_vars)
     unique_sdk.api_base = get_env("API_BASE", default=None, strict=strict_all_vars)

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/app/schemas.py

@@ -19,6 +19,15 @@ model_config = ConfigDict(
 
 class EventName(StrEnum):
     EXTERNAL_MODULE_CHOSEN = "unique.chat.external-module.chosen"
+    USER_MESSAGE_CREATED = "unique.chat.user-message.created"
+    INGESTION_CONTENT_UPLOADED = "unique.ingestion.content.uploaded"
+    INGESTION_CONTENT_FINISHED = "unique.ingestion.content.finished"
+    MAGIC_TABLE_IMPORT_COLUMNS = "unique.magic-table.import-columns"
+    MAGIC_TABLE_ADD_META_DATA = "unique.magic-table.add-meta-data"
+    MAGIC_TABLE_ADD_DOCUMENT = "unique.magic-table.add-document"
+    MAGIC_TABLE_DELETE_ROW = "unique.magic-table.delete-row"
+    MAGIC_TABLE_DELETE_COLUMN = "unique.magic-table.delete-column"
+    MAGIC_TABLE_UPDATE_CELL = "unique.magic-table.update-cell"
 
 
 class BaseEvent(BaseModel):

unique_toolkit-0.8.2/unique_toolkit/app/unique_settings.py

@@ -0,0 +1,134 @@
+from logging import getLogger
+from pathlib import Path
+from typing import Self, TypeVar
+from urllib.parse import urlparse, urlunparse
+
+from pydantic import Field, SecretStr, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+logger = getLogger(__name__)
+
+T = TypeVar("T", bound=BaseSettings)
+
+
+def warn_about_defaults(instance: T) -> T:
+    """Log warnings for fields that are using default values."""
+    for field_name, model_field in instance.model_fields.items():
+        field_value = getattr(instance, field_name)
+        if field_value == model_field.default:
+            logger.warning(
+                f"Using default value for '{field_name}': {model_field.default}"
+            )
+    return instance
+
+
+class UniqueApp(BaseSettings):
+    id: SecretStr = Field(default=SecretStr("dummy_id"))
+    key: SecretStr = Field(default=SecretStr("dummy_key"))
+    base_url: str = Field(
+        default="http://localhost:8092/",
+        deprecated="Use UniqueApi.base_url instead",
+    )
+    endpoint: str = Field(default="dummy")
+    endpoint_secret: SecretStr = Field(default=SecretStr("dummy_secret"))
+
+    @model_validator(mode="after")
+    def _warn_about_defaults(self) -> Self:
+        return warn_about_defaults(self)
+
+    model_config = SettingsConfigDict(
+        env_prefix="unique_app_",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+
+class UniqueApi(BaseSettings):
+    base_url: str = Field(
+        default="http://localhost:8092/",
+        description="The base URL of the Unique API. Ask your admin to provide you with the correct URL.",
+    )
+    version: str = Field(default="2023-12-06")
+
+    model_config = SettingsConfigDict(
+        env_prefix="unique_api_",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    @model_validator(mode="after")
+    def _warn_about_defaults(self) -> Self:
+        return warn_about_defaults(self)
+
+    def sse_url(self, subscriptions: list[str]) -> str:
+        parsed = urlparse(self.base_url)
+        return urlunparse(
+            parsed._replace(
+                path="/public/event-socket/events/stream",
+                query=f"subscriptions={','.join(subscriptions)}",
+                fragment=None,
+            )
+        )
+
+    def sdk_url(self) -> str:
+        parsed = urlparse(self.base_url)
+
+        path = "/public/chat"
+        if parsed.hostname and "qa.unique" in parsed.hostname:
+            path = "/public/chat-gen2"
+        return urlunparse(parsed._replace(path=path, query=None, fragment=None))
+
+    def openai_proxy_url(self) -> str:
+        parsed = urlparse(self.base_url)
+        return urlunparse(
+            parsed._replace(path="/public/openai-proxy/", query=None, fragment=None)
+        )
+
+
+class UniqueAuth(BaseSettings):
+    company_id: SecretStr = Field(default=SecretStr("dummy_company_id"))
+    user_id: SecretStr = Field(default=SecretStr("dummy_user_id"))
+
+    model_config = SettingsConfigDict(
+        env_prefix="unique_auth_",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    @model_validator(mode="after")
+    def _warn_about_defaults(self) -> Self:
+        return warn_about_defaults(self)
+
+
+class UniqueSettings:
+    def __init__(self, auth: UniqueAuth, app: UniqueApp, api: UniqueApi):
+        self.app = app
+        self.auth = auth
+        self.api = api
+
+    @classmethod
+    def from_env(cls, env_file: Path | None = None) -> "UniqueSettings":
+        """Initialize settings from environment variables and/or env file.
+
+        Args:
+            env_file: Optional path to environment file. If provided, will load variables from this file.
+
+        Returns:
+            UniqueSettings instance with values loaded from environment/env file.
+
+        Raises:
+            FileNotFoundError: If env_file is provided but does not exist.
+            ValidationError: If required environment variables are missing.
+        """
+        if env_file and not env_file.exists():
+            raise FileNotFoundError(f"Environment file not found: {env_file}")
+
+        # Initialize settings with environment file if provided
+        env_file_str = str(env_file) if env_file else None
+        auth = UniqueAuth(_env_file=env_file_str)
+        app = UniqueApp(_env_file=env_file_str)
+        api = UniqueApi(_env_file=env_file_str)
+        return cls(auth=auth, app=app, api=api)

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/chat/service.py

@@ -57,15 +57,6 @@ logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 class ChatService:
     """
     Provides all functionalities to manage the chat session.
-
-    Attributes:
-        company_id (str | None): The company ID.
-        user_id (str | None): The user ID.
-        assistant_message_id (str | None): The assistant message ID.
-        user_message_id (str | None): The user message ID.
-        chat_id (str | None): The chat ID.
-        assistant_id (str | None): The assistant ID.
-        user_message_text (str | None): The user message text.
     """
 
     def __init__(self, event: ChatEvent | Event):
@@ -88,6 +79,7 @@ class ChatService:
 
         Returns:
             Event | BaseEvent | None: The event object.
+
         """
         return self._event
 
@@ -101,6 +93,7 @@ class ChatService:
 
         Returns:
             str | None: The company identifier.
+
         """
         return self._company_id
 

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/content/service.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Any
+from typing import Any, overload
 
 import unique_sdk
 from requests import Response
@@ -35,13 +35,30 @@ logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 class ContentService:
     """
     Provides methods for searching, downloading and uploading content in the knowledge base.
+    """
+
+    @deprecated(
+        "Use __init__ with company_id, user_id and chat_id instead or use the classmethod `from_event`"
+    )
+    @overload
+    def __init__(self, event: Event | ChatEvent | BaseEvent): ...
+
+    """
+        Initialize the ContentService with an event (deprecated)
+    """
+
+    @overload
+    def __init__(
+        self,
+        *,
+        company_id: str,
+        user_id: str,
+        chat_id: str | None,
+        metadata_filter: dict | None = None,
+    ): ...
 
-    Attributes:
-        event: BaseEvent | Event, this can be None ONLY if company_id and user_id are provided.
-        company_id (str): The company ID.
-        user_id (str): The user ID.
-        chat_id (str): The chat ID. Defaults to None
-        metadata_filter (dict | None): is only initialised from an Event(Deprecated) or ChatEvent.
+    """
+        Initialize the ContentService with a company_id, user_id and chat_id and metadata_filter.
     """
 
     def __init__(
@@ -50,7 +67,12 @@ class ContentService:
         company_id: str | None = None,
         user_id: str | None = None,
         chat_id: str | None = None,
+        metadata_filter: dict | None = None,
     ):
+        """
+        Initialize the ContentService with a company_id, user_id and chat_id.
+        """
+
         self._event = event  # Changed to protected attribute
         self._metadata_filter = None
         if event:
@@ -64,6 +86,26 @@ class ContentService:
             self._company_id: str = company_id
             self._user_id: str = user_id
             self._chat_id: str | None = chat_id
+            self._metadata_filter = metadata_filter
+
+    @classmethod
+    def from_event(cls, event: Event | ChatEvent | BaseEvent):
+        """
+        Initialize the ContentService with an event.
+        """
+        chat_id = None
+        metadata_filter = None
+
+        if isinstance(event, (ChatEvent | Event)):
+            chat_id = event.payload.chat_id
+            metadata_filter = event.payload.metadata_filter
+
+        return cls(
+            company_id=event.company_id,
+            user_id=event.user_id,
+            chat_id=chat_id,
+            metadata_filter=metadata_filter,
+        )
 
     @property
     @deprecated(

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/embedding/service.py

@@ -1,3 +1,5 @@
+from typing import overload
+
 from typing_extensions import deprecated
 
 from unique_toolkit._common._base_service import BaseService
@@ -11,10 +13,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__(
@@ -32,6 +47,13 @@ class EmbeddingService(BaseService):
             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)
+
     @property
     @deprecated(
         "The event property is deprecated and will be removed in a future version."

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/framework_utilities/langchain/client.py

@@ -1,6 +1,5 @@
 import importlib.util
 import logging
-from pathlib import Path
 
 from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.framework_utilities.utils import get_default_headers
@@ -23,11 +22,13 @@ else:
     raise LangchainNotInstalledError()
 
 
-def get_client(env_file: Path | None = None) -> ChatOpenAI:
+def get_client(
+    unique_settings: UniqueSettings, model: str = "AZURE_GPT_4o_2024_0806"
+) -> ChatOpenAI:
     """Get a Langchain ChatOpenAI client instance.
 
     Args:
-        env_file: Optional path to environment file
+        unique_settings: UniqueSettings instance
 
     Returns:
         ChatOpenAI client instance
@@ -35,11 +36,10 @@ def get_client(env_file: Path | None = None) -> ChatOpenAI:
     Raises:
         LangchainNotInstalledError: If langchain-openai package is not installed
     """
-    settings = UniqueSettings.from_env(env_file=env_file)
 
     return ChatOpenAI(
-        base_url=settings.app.base_url + "/openai-proxy/",
-        default_headers=get_default_headers(settings.app, settings.auth),
-        model="AZURE_GPT_4o_2024_0806",
-        api_key=settings.app.key,
+        base_url=unique_settings.api.openai_proxy_url(),
+        default_headers=get_default_headers(unique_settings.app, unique_settings.auth),
+        model=model,
+        api_key=unique_settings.app.key,
     )

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/framework_utilities/openai/client.py

@@ -1,6 +1,5 @@
 import importlib.util
 import logging
-from pathlib import Path
 
 from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.framework_utilities.utils import get_default_headers
@@ -23,7 +22,7 @@ else:
     raise OpenAINotInstalledError()
 
 
-def get_openai_client(env_file: Path | None = None) -> OpenAI:
+def get_openai_client(unique_settings: UniqueSettings) -> OpenAI:
     """Get an OpenAI client instance.
 
     Args:
@@ -35,11 +34,10 @@ def get_openai_client(env_file: Path | None = None) -> OpenAI:
     Raises:
         OpenAINotInstalledError: If OpenAI package is not installed
     """
-    settings = UniqueSettings.from_env(env_file=env_file)
-    default_headers = get_default_headers(settings.app, settings.auth)
+    default_headers = get_default_headers(unique_settings.app, unique_settings.auth)
 
     return OpenAI(
-        api_key=settings.app.key.get_secret_value(),
-        base_url=settings.app.base_url + "/openai-proxy/",
+        api_key=unique_settings.app.key.get_secret_value(),
+        base_url=unique_settings.api.openai_proxy_url(),
         default_headers=default_headers,
     )

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/language_model/service.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Optional, Type
+from typing import Any, Optional, Type, overload
 
 from pydantic import BaseModel
 from typing_extensions import deprecated
@@ -33,36 +33,61 @@ logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 class LanguageModelService:
     """
     Provides methods to interact with the Language Model by generating responses.
+    """
+
+    @deprecated(
+        "Use __init__ with company_id and user_id instead or use the classmethod `from_event`"
+    )
+    @overload
+    def __init__(self, event: Event | ChatEvent | BaseEvent): ...
+
+    """
+        Initialize the LanguageModelService with an event (deprecated)
+    """
+
+    @overload
+    def __init__(self, *, company_id: str, user_id: str): ...
 
-    Args:
-        company_id (str | None, optional): The company identifier. Defaults to None.
-        user_id (str | None, optional): The user identifier. Defaults to None.
-        chat_id (str | None, optional): The chat identifier. Defaults to None.
-        assistant_id (str | None, optional): The assistant identifier. Defaults to None.
+    """
+        Initialize the LanguageModelService with a company_id and user_id.
     """
 
     def __init__(
         self,
-        event: Event | BaseEvent | None = None,
+        event: Event | ChatEvent | BaseEvent | None = None,
         company_id: str | None = None,
         user_id: str | None = None,
-        chat_id: str | None = None,
-        assistant_id: str | None = None,
+        **kwargs: dict[str, Any],  # only here for backward compatibility
     ):
-        self._event = event
-        self._chat_id: str | None = chat_id
-        self._assistant_id: str | None = assistant_id
-
-        if event:
+        if isinstance(event, (ChatEvent, Event)):
+            self._event = event
+            self._chat_id: str | None = event.payload.chat_id
+            self._assistant_id: str | None = event.payload.assistant_id
             self._company_id = event.company_id
             self._user_id = event.user_id
             if isinstance(event, (ChatEvent, Event)):
                 self._chat_id = event.payload.chat_id
                 self._assistant_id = event.payload.assistant_id
+        elif isinstance(event, BaseEvent):
+            self._event = event
+            self._company_id = event.company_id
+            self._user_id = event.user_id
+            self._chat_id: str | None = None
+            self._assistant_id: str | None = None
         else:
             [company_id, user_id] = validate_required_values([company_id, user_id])
+            self._event = None
             self._company_id: str = company_id
             self._user_id: str = user_id
+            self._chat_id: str | None = None
+            self._assistant_id: str | None = None
+
+    @classmethod
+    def from_event(cls, event: BaseEvent):
+        """
+        Initialize the LanguageModelService with an event.
+        """
+        return cls(company_id=event.company_id, user_id=event.user_id)
 
     @property
     @deprecated(

{unique_toolkit-0.8.0 → unique_toolkit-0.8.2}/unique_toolkit/short_term_memory/service.py

@@ -1,3 +1,5 @@
+from typing import overload
+
 from typing_extensions import deprecated
 
 from unique_toolkit._common.validate_required_values import validate_required_values
@@ -16,17 +18,35 @@ from .schemas import ShortTermMemory
 class ShortTermMemoryService:
     """
     Provides methods to manage short term memory.
+    """
+
+    @deprecated(
+        "Use __init__ with company_id and user_id instead or use the classmethod `from_event`"
+    )
+    @overload
+    def __init__(self, event: Event | ChatEvent | BaseEvent): ...
+
+    """
+        Initialize the ShortTermMemoryService with an event (deprecated)
+    """
+
+    @overload
+    def __init__(
+        self,
+        *,
+        company_id: str,
+        user_id: str,
+        chat_id: str | None,
+        message_id: str | None,
+    ): ...
 
-    Attributes:
-        user_id (str | None): The user ID.
-        company_id (str | None): The company ID.
-        chat_id (str | None): The chat ID.
-        message_id (str | None): The message ID.
+    """
+        Initialize the ShortTermMemoryService with a company_id, user_id, chat_id and message_id.
     """
 
     def __init__(
         self,
-        event: Event | BaseEvent | None = None,
+        event: Event | ChatEvent | BaseEvent | None = None,
         user_id: str | None = None,
         company_id: str | None = None,
         chat_id: str | None = None,
@@ -50,6 +70,18 @@ class ShortTermMemoryService:
             self._chat_id: str | None = chat_id
             self._message_id: str | None = message_id
 
+    @classmethod
+    def from_event(cls, event: ChatEvent):
+        """
+        Initialize the ShortTermMemoryService with a chat event.
+        """
+        return cls(
+            company_id=event.company_id,
+            user_id=event.user_id,
+            chat_id=event.payload.chat_id,
+            message_id=event.payload.user_message.id,
+        )
+
     @property
     @deprecated(
         "The event property is deprecated and will be removed in a future version."

unique_toolkit-0.8.0/unique_toolkit/app/event_util.py

@@ -1,24 +0,0 @@
-import json
-from logging import getLogger
-from typing import Literal, overload
-
-from unique_toolkit.app import ChatEvent, EventName
-
-LOGGER = getLogger(__name__)
-
-
-@overload
-def load_and_filter_event(
-    event: dict,
-    event_type: Literal[EventName.EXTERNAL_MODULE_CHOSEN],
-) -> type[ChatEvent] | None: ...
-
-
-def load_and_filter_event(event: dict, event_type: EventName):
-    event = json.loads(event.data)
-
-    match event_type:
-        case EventName.EXTERNAL_MODULE_CHOSEN:
-            return ChatEvent(**event)
-
-    return None

unique_toolkit-0.8.0/unique_toolkit/app/sse_client.py

@@ -1,20 +0,0 @@
-from logging import getLogger
-
-from sseclient import SSEClient
-
-from unique_toolkit.app.unique_settings import UniqueSettings
-
-LOGGER = getLogger(__name__)
-
-
-def get_sse_client(
-    unique_settings: UniqueSettings,
-    subscriptions: list[str],
-) -> SSEClient:
-    url = f"{unique_settings.app.base_url}/public/event-socket/events/stream?subscriptions={','.join(subscriptions)}"
-    headers = {
-        "Authorization": f"Bearer {unique_settings.app.key.get_secret_value()}",
-        "x-app-id": unique_settings.app.id.get_secret_value(),
-        "x-company-id": unique_settings.auth.company_id.get_secret_value(),
-    }
-    return SSEClient(url=url, headers=headers)

unique_toolkit-0.8.0/unique_toolkit/app/unique_settings.py

@@ -1,61 +0,0 @@
-from pathlib import Path
-
-from pydantic import SecretStr
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class UniqueApp(BaseSettings):
-    id: SecretStr
-    key: SecretStr
-    base_url: str
-    endpoint: str
-    endpoint_secret: SecretStr
-
-    model_config = SettingsConfigDict(
-        env_prefix="unique_app_",
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-        extra="ignore",
-    )
-
-
-class UniqueAuth(BaseSettings):
-    company_id: SecretStr
-    user_id: SecretStr
-
-    model_config = SettingsConfigDict(
-        env_prefix="unique_auth_",
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-        extra="ignore",
-    )
-
-
-class UniqueSettings:
-    def __init__(self, auth: UniqueAuth, app: UniqueApp):
-        self.app = app
-        self.auth = auth
-
-    @classmethod
-    def from_env(cls, env_file: Path | None = None) -> "UniqueSettings":
-        """Initialize settings from environment variables and/or env file.
-
-        Args:
-            env_file: Optional path to environment file. If provided, will load variables from this file.
-
-        Returns:
-            UniqueSettings instance with values loaded from environment/env file.
-
-        Raises:
-            FileNotFoundError: If env_file is provided but does not exist.
-            ValidationError: If required environment variables are missing.
-        """
-        if env_file and not env_file.exists():
-            raise FileNotFoundError(f"Environment file not found: {env_file}")
-
-        # Initialize settings with environment file if provided
-        env_file_str = str(env_file) if env_file else None
-        auth = UniqueAuth(_env_file=env_file_str, _env_file_encoding="utf-8")
-        app = UniqueApp(_env_file=env_file_str, _env_file_encoding="utf-8")
-
-        return cls(auth=auth, app=app)