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

unique_toolkit/content/smart_rules.py

@@ -0,0 +1,301 @@
+import re
+from datetime import datetime, timedelta, timezone
+from enum import Enum
+from typing import Any, Dict, List, Mapping, Self, Union
+
+from pydantic import AliasChoices, BaseModel, Field
+from pydantic.config import ConfigDict
+
+
+class Operator(str, Enum):
+    EQUALS = "equals"
+    NOT_EQUALS = "notEquals"
+    GREATER_THAN = "greaterThan"
+    GREATER_THAN_OR_EQUAL = "greaterThanOrEqual"
+    LESS_THAN = "lessThan"
+    LESS_THAN_OR_EQUAL = "lessThanOrEqual"
+    IN = "in"
+    NOT_IN = "notIn"
+    CONTAINS = "contains"
+    NOT_CONTAINS = "notContains"
+    IS_NULL = "isNull"
+    IS_NOT_NULL = "isNotNull"
+    IS_EMPTY = "isEmpty"
+    IS_NOT_EMPTY = "isNotEmpty"
+    NESTED = "nested"
+
+
+class BaseStatement(BaseModel):
+    model_config = ConfigDict(serialize_by_alias=True)
+
+    def with_variables(
+        self,
+        user_metadata: Mapping[str, Union[str, int, bool]],
+        tool_parameters: Mapping[str, Union[str, int, bool]],
+    ) -> Self:
+        return self._fill_in_variables(user_metadata, tool_parameters)
+
+    def is_compiled(self) -> bool:
+        # Serialize the object to json string
+        json_str = self.model_dump_json()
+        # Check if the json string has <T> or <T+> or <T-> or <toolParameters or <userMetadata
+        return (
+            "<T>" in json_str
+            or "<T+" in json_str
+            or "<T-" in json_str
+            or "<toolParameters" in json_str
+            or "<userMetadata" in json_str
+        )
+
+    def _fill_in_variables(
+        self,
+        user_metadata: Mapping[str, Union[str, int, bool]],
+        tool_parameters: Mapping[str, Union[str, int, bool]],
+    ) -> Self:
+        return self.model_copy()
+
+
+class Statement(BaseStatement):
+    operator: Operator
+    value: Union[str, int, bool, list[str], "AndStatement", "OrStatement"]
+    path: List[str] = Field(default_factory=list)
+
+    def _fill_in_variables(
+        self,
+        user_metadata: Mapping[str, Union[str, int, bool]],
+        tool_parameters: Mapping[str, Union[str, int, bool]],
+    ) -> Self:
+        new_stmt = self.model_copy()
+        new_stmt.value = eval_operator(self, user_metadata, tool_parameters)
+        return new_stmt
+
+
+class AndStatement(BaseStatement):
+    and_list: List[Union["Statement", "AndStatement", "OrStatement"]] = Field(
+        validation_alias=AliasChoices("and", "and_list"), serialization_alias="and"
+    )
+
+    def _fill_in_variables(
+        self,
+        user_metadata: Mapping[str, Union[str, int, bool]],
+        tool_parameters: Mapping[str, Union[str, int, bool]],
+    ) -> Self:
+        new_stmt = self.model_copy()
+        new_stmt.and_list = [
+            sub_query._fill_in_variables(user_metadata, tool_parameters)
+            for sub_query in self.and_list
+        ]
+        return new_stmt
+
+
+class OrStatement(BaseStatement):
+    or_list: List[Union["Statement", "AndStatement", "OrStatement"]] = Field(
+        validation_alias=AliasChoices("or", "or_list"), serialization_alias="or"
+    )
+
+    def _fill_in_variables(
+        self,
+        user_metadata: Mapping[str, Union[str, int, bool]],
+        tool_parameters: Mapping[str, Union[str, int, bool]],
+    ) -> Self:
+        new_stmt = self.model_copy()
+        new_stmt.or_list = [
+            sub_query._fill_in_variables(user_metadata, tool_parameters)
+            for sub_query in self.or_list
+        ]
+        return new_stmt
+
+
+# Update the forward references
+Statement.model_rebuild()
+AndStatement.model_rebuild()
+OrStatement.model_rebuild()
+
+
+UniqueQL = Union[Statement, AndStatement, OrStatement]
+
+
+def is_array_of_strings(value: Any) -> bool:
+    return isinstance(value, list) and all(isinstance(item, str) for item in value)
+
+
+def eval_operator(
+    query: Statement,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    if query.operator in [
+        Operator.EQUALS,
+        Operator.NOT_EQUALS,
+        Operator.GREATER_THAN,
+        Operator.GREATER_THAN_OR_EQUAL,
+        Operator.LESS_THAN,
+        Operator.LESS_THAN_OR_EQUAL,
+        Operator.CONTAINS,
+        Operator.NOT_CONTAINS,
+    ]:
+        return binary_operator(query.value, user_metadata, tool_parameters)
+    elif query.operator in [Operator.IS_NULL, Operator.IS_NOT_NULL]:
+        return null_operator(query.value, user_metadata, tool_parameters)
+    elif query.operator in [Operator.IS_EMPTY, Operator.IS_NOT_EMPTY]:
+        return empty_operator(query.operator, user_metadata, tool_parameters)
+    elif query.operator == Operator.NESTED:
+        return eval_nested_operator(query.value, user_metadata, tool_parameters)
+    elif query.operator in [Operator.IN, Operator.NOT_IN]:
+        return array_operator(query.value, user_metadata, tool_parameters)
+    else:
+        raise ValueError(f"Operator {query.operator} not supported")
+
+
+def eval_nested_operator(
+    value: Any,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Union[AndStatement, OrStatement]:
+    if not isinstance(value, (AndStatement, OrStatement)):
+        raise ValueError("Nested operator must be an AndStatement or OrStatement")
+    return value._fill_in_variables(user_metadata, tool_parameters)
+
+
+def binary_operator(
+    value: Any,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    return replace_variables(value, user_metadata, tool_parameters)
+
+
+def array_operator(
+    value: Any,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    if is_array_of_strings(value):
+        return [
+            replace_variables(item, user_metadata, tool_parameters) for item in value
+        ]
+    return value
+
+
+def null_operator(
+    value: Any,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    return value  # do nothing for now. No variables to replace
+
+
+def empty_operator(
+    operator: Operator,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    """Handle IS_EMPTY and IS_NOT_EMPTY operators."""
+    if operator == Operator.IS_EMPTY:
+        return ""
+    elif operator == Operator.IS_NOT_EMPTY:
+        return "not_empty"
+    return None
+
+
+def calculate_current_date() -> str:
+    """Calculate current date in UTC with seconds precision."""
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def calculate_earlier_date(input_str: str) -> str:
+    match = re.search(r"<T-(\d+)>", input_str)
+    if not match:
+        return calculate_current_date()  # Return current date if no match
+    days = int(match.group(1))
+    return (datetime.now(timezone.utc) - timedelta(days=days)).isoformat(
+        timespec="seconds"
+    )
+
+
+def calculate_later_date(input_str: str) -> str:
+    match = re.search(r"<T\+(\d+)>", input_str)  # Note: escaped + in regex
+    if not match:
+        return calculate_current_date()  # Return current date if no match
+    days = int(match.group(1))
+    return (datetime.now(timezone.utc) + timedelta(days=days)).isoformat(
+        timespec="seconds"
+    )
+
+
+def replace_variables(
+    value: Any,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    if isinstance(value, str):
+        if "||" in value:
+            return get_fallback_values(value, user_metadata, tool_parameters)
+        elif value == "<T>":
+            return calculate_current_date()
+        elif "<T-" in value:
+            return calculate_earlier_date(value)
+        elif "<T+" in value:
+            return calculate_later_date(value)
+
+        value = replace_tool_parameters_patterns(value, tool_parameters)
+        value = replace_user_metadata_patterns(value, user_metadata)
+
+        if value == "":
+            return value
+        try:
+            return int(value)
+        except ValueError:
+            if value.lower() in ["true", "false"]:
+                return value.lower() == "true"
+            return value
+    return value
+
+
+def replace_tool_parameters_patterns(
+    value: str, tool_parameters: Dict[str, Union[str, int, bool]]
+) -> str:
+    def replace_match(match):
+        param_name = match.group(1)
+        return str(tool_parameters.get(param_name, ""))
+
+    return re.sub(r"<toolParameters\.(\w+)>", replace_match, value)
+
+
+def replace_user_metadata_patterns(
+    value: str, user_metadata: Dict[str, Union[str, int, bool]]
+) -> str:
+    def replace_match(match):
+        param_name = match.group(1)
+        return str(user_metadata.get(param_name, ""))
+
+    return re.sub(r"<userMetadata\.(\w+)>", replace_match, value)
+
+
+def get_fallback_values(
+    value: str,
+    user_metadata: Mapping[str, Union[str, int, bool]],
+    tool_parameters: Mapping[str, Union[str, int, bool]],
+) -> Any:
+    values = value.split("||")
+    for val in values:
+        data = replace_variables(val, user_metadata, tool_parameters)
+        if data != "":
+            return data
+    return values
+
+
+# Example usage:
+def parse_uniqueql(json_data: Dict[str, Any]) -> UniqueQL:
+    if "operator" in json_data:
+        return Statement.model_validate(json_data)
+    elif "or" in json_data:
+        return OrStatement.model_validate(
+            {"or": [parse_uniqueql(item) for item in json_data["or"]]}
+        )
+    elif "and" in json_data:
+        return AndStatement.model_validate(
+            {"and": [parse_uniqueql(item) for item in json_data["and"]]}
+        )
+    else:
+        raise ValueError("Invalid UniqueQL format")

unique_toolkit/content/utils.py

@@ -190,9 +190,11 @@ def count_tokens(text: str, encoding_model="cl100k_base") -> int:
     return len(encoding.encode(text))
 
 
-def map_content_chunk(content_chunk: dict):
+def map_content_chunk(content_id: str, content_key: str, content_chunk: dict):
     return ContentChunk(
-        id=content_chunk["id"],
+        id=content_id,
+        key=content_key,
+        chunk_id=content_chunk["id"],
         text=content_chunk["text"],
         start_page=content_chunk["startPage"],
         end_page=content_chunk["endPage"],
@@ -206,7 +208,10 @@ def map_content(content: dict):
         key=content["key"],
         title=content["title"],
         url=content["url"],
-        chunks=[map_content_chunk(chunk) for chunk in content["chunks"]],
+        chunks=[
+            map_content_chunk(content["id"], content["key"], chunk)
+            for chunk in content["chunks"]
+        ],
         created_at=content["createdAt"],
         updated_at=content["updatedAt"],
     )

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],
@@ -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/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,83 @@
+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:
+        env_file: Optional path to environment file
+
+    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,
+    )