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

unique_toolkit/content/functions.py

@@ -13,8 +13,12 @@ from unique_toolkit.content.constants import DEFAULT_SEARCH_LANGUAGE
 from unique_toolkit.content.schemas import (
     Content,
     ContentChunk,
+    ContentInfo,
     ContentRerankerConfig,
     ContentSearchType,
+    DeleteContentResponse,
+    FolderInfo,
+    PaginatedContentInfos,
 )
 from unique_toolkit.content.utils import map_contents, map_to_content_chunks
 
@@ -429,7 +433,7 @@ def _trigger_upload_content(
             scope_id=scope_id,
         )  # type: ignore
 
-    return Content(**created_content)
+    return Content.model_validate(created_content, by_alias=True, by_name=True)
 
 
 def request_content_by_id(
@@ -577,3 +581,114 @@ def download_content(
         raise Exception(error_msg)
 
     return content_path
+
+
+def get_content_info(
+    user_id: str,
+    company_id: str,
+    *,
+    metadata_filter: dict[str, Any] | None = None,
+    skip: int | None = None,
+    take: int | None = None,
+    file_path: str | None = None,
+):
+    """Gets the info of a content."""
+
+    get_info_params = unique_sdk.Content.ContentInfoParams(
+        metadataFilter=metadata_filter or None,  # Dict cannot be empty
+    )
+    if skip:
+        get_info_params["skip"] = skip
+    if take:
+        get_info_params["take"] = take
+    if file_path:
+        get_info_params["filePath"] = file_path
+
+    content_info = unique_sdk.Content.get_infos(
+        user_id=user_id, company_id=company_id, **get_info_params
+    )
+    return PaginatedContentInfos.model_validate(
+        content_info, by_alias=True, by_name=True
+    )
+
+
+def get_folder_info(user_id: str, company_id: str, *, scope_id: str) -> FolderInfo:
+    info = unique_sdk.Folder.get_info(
+        user_id=user_id, company_id=company_id, scopeId=scope_id
+    )
+
+    return FolderInfo.model_validate(info, by_alias=True, by_name=True)
+
+
+def update_content(
+    user_id: str,
+    company_id: str,
+    *,
+    content_id: str,
+    metadata: dict[str, Any],
+    file_path: str | None = None,
+    owner_id: str | None = None,
+    parent_folder_path: str | None = None,
+    title: str | None = None,
+) -> ContentInfo:
+    """Updates the metadata of a content."""
+
+    update_params = unique_sdk.Content.UpdateParams(
+        contentId=content_id, metadata=metadata
+    )
+
+    if file_path:
+        update_params["filePath"] = file_path
+    if owner_id:
+        update_params["ownerId"] = owner_id
+    if parent_folder_path:
+        update_params["parentFolderPath"] = parent_folder_path
+    if title:
+        update_params["title"] = title
+
+    content_info = unique_sdk.Content.update(
+        user_id=user_id, company_id=company_id, **update_params
+    )
+    return ContentInfo.model_validate(content_info, by_alias=True, by_name=True)
+
+
+def delete_content(
+    user_id: str,
+    company_id: str,
+    *,
+    content_id: str | None = None,
+    file_path: str | None = None,
+) -> DeleteContentResponse:
+    if content_id:
+        resp = unique_sdk.Content.delete(
+            user_id=user_id, company_id=company_id, contentId=content_id
+        )
+    elif file_path:
+        resp = unique_sdk.Content.delete(
+            user_id=user_id, company_id=company_id, filePath=file_path
+        )
+    else:
+        raise ValueError("content_id or file_path must be provided")
+
+    return DeleteContentResponse.model_validate(resp, by_alias=True, by_name=True)
+
+
+async def delete_content_async(
+    user_id: str,
+    company_id: str,
+    *,
+    content_id: str | None = None,
+    file_path: str | None = None,
+) -> DeleteContentResponse:
+    if content_id:
+        resp = await unique_sdk.Content.delete_async(
+            user_id=user_id, company_id=company_id, contentId=content_id
+        )
+    elif file_path:
+        resp = await unique_sdk.Content.delete_async(
+            user_id=user_id, company_id=company_id, filePath=file_path
+        )
+    else:
+        raise ValueError("content_id or file_path must be provided")
+
+    return DeleteContentResponse.model_validate(resp, by_alias=True, by_name=True)

unique_toolkit/content/schemas.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from enum import StrEnum
 from typing import Any, Optional
 
+import unique_sdk
 from humps import camelize
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -114,6 +115,22 @@ class ContentReference(BaseModel):
         description="List of indices in the ChatMessage original_content this reference refers to. This is usually the id in the functionCallResponse. List type due to implementation in node-chat",
     )
 
+    @classmethod
+    def from_sdk_reference(
+        cls, reference: unique_sdk.Message.Reference | unique_sdk.Space.Reference
+    ) -> "ContentReference":
+        kwargs = {
+            "name": reference["name"],
+            "url": reference["url"],
+            "sequence_number": reference["sequenceNumber"],
+            "source": reference["source"],
+            "source_id": reference["sourceId"],
+        }
+        if "originalIndex" in reference:
+            kwargs["original_index"] = reference["originalIndex"]
+
+        return cls.model_validate(kwargs)
+
 
 class ContentSearchType(StrEnum):
     COMBINED = "COMBINED"
@@ -149,3 +166,45 @@ class ContentRerankerConfig(BaseModel):
     model_config = model_config
     deployment_name: str = Field(serialization_alias="deploymentName")
     options: dict | None = None
+
+
+class ContentInfo(BaseModel):
+    model_config = model_config
+    id: str
+    object: str
+    key: str
+    url: str | None = None
+    title: str | None = None
+    metadata: dict[str, Any] | None = None
+    byte_size: int
+    mime_type: str
+    owner_id: str
+    created_at: datetime
+    updated_at: datetime
+    expires_at: datetime | None = None
+    deleted_at: datetime | None = None
+    expired_at: datetime | None = None
+
+
+class PaginatedContentInfos(BaseModel):
+    model_config = model_config
+    object: str
+    content_infos: list[ContentInfo]
+    total_count: int
+
+
+class FolderInfo(BaseModel):
+    model_config = model_config
+    id: str
+    name: str
+    ingestion_config: dict[str, Any]
+    createdAt: str | None
+    updatedAt: str | None
+    parentId: str | None
+    externalId: str | None
+
+
+class DeleteContentResponse(BaseModel):
+    model_config = model_config
+    content_id: str
+    object: str

unique_toolkit/content/service.py

@@ -1,6 +1,4 @@
 import logging
-import mimetypes
-from enum import StrEnum
 from pathlib import Path
 from typing import Any, overload
 
@@ -8,6 +6,7 @@ import unique_sdk
 from requests import Response
 from typing_extensions import deprecated
 
+from unique_toolkit._common.utils.files import is_file_content, is_image_content
 from unique_toolkit._common.validate_required_values import validate_required_values
 from unique_toolkit.app.schemas import BaseEvent, ChatEvent, Event
 from unique_toolkit.app.unique_settings import UniqueSettings
@@ -35,29 +34,7 @@ from unique_toolkit.content.schemas import (
 logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 
 
-class FileMimeType(StrEnum):
-    PDF = "application/pdf"
-    DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-    DOC = "application/msword"
-    XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-    XLS = "application/vnd.ms-excel"
-    PPTX = "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-    CSV = "text/csv"
-    HTML = "text/html"
-    MD = "text/markdown"
-    TXT = "text/plain"
-
-
-class ImageMimeType(StrEnum):
-    JPEG = "image/jpeg"
-    PNG = "image/png"
-    GIF = "image/gif"
-    BMP = "image/bmp"
-    WEBP = "image/webp"
-    TIFF = "image/tiff"
-    SVG = "image/svg+xml"
-
-
+@deprecated("Use KnowledgeBaseService instead")
 class ContentService:
     """
     Provides methods for searching, downloading and uploading content in the knowledge base.
@@ -337,6 +314,7 @@ class ContentService:
             logger.error(f"Error while searching content chunks: {e}")
             raise e
 
+    @deprecated("Use search_chunks_async instead")
     async def search_content_chunks_async(
         self,
         search_string: str,
@@ -694,17 +672,7 @@ class ContentService:
         return content
 
     def is_file_content(self, filename: str) -> bool:
-        mimetype, _ = mimetypes.guess_type(filename)
-
-        if not mimetype:
-            return False
-
-        return mimetype in FileMimeType.__members__.values()
+        return is_file_content(filename=filename)
 
     def is_image_content(self, filename: str) -> bool:
-        mimetype, _ = mimetypes.guess_type(filename)
-
-        if not mimetype:
-            return False
-
-        return mimetype in ImageMimeType.__members__.values()
+        return is_image_content(filename=filename)

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/framework_utilities/langchain/client.py

@@ -1,6 +1,8 @@
 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
 
@@ -22,8 +24,11 @@ else:
     raise LangchainNotInstalledError()
 
 
-def get_client(
-    unique_settings: UniqueSettings | None = None, model: str = "AZURE_GPT_4o_2024_0806"
+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.
 
@@ -39,9 +44,28 @@ def get_client(
     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=get_default_headers(unique_settings.app, unique_settings.auth),
+        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/openai/client.py

@@ -22,7 +22,11 @@ else:
     raise OpenAINotInstalledError()
 
 
-def get_openai_client(unique_settings: UniqueSettings | None = None) -> OpenAI:
+def get_openai_client(
+    *,
+    unique_settings: UniqueSettings | None = None,
+    additional_headers: dict[str, str] | None = None,
+) -> OpenAI:
     """Get an OpenAI client instance.
 
     Args:
@@ -38,6 +42,8 @@ def get_openai_client(unique_settings: UniqueSettings | None = None) -> OpenAI:
         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",
@@ -47,7 +53,9 @@ def get_openai_client(unique_settings: UniqueSettings | None = None) -> OpenAI:
 
 
 def get_async_openai_client(
+    *,
     unique_settings: UniqueSettings | None = None,
+    additional_headers: dict[str, str] | None = None,
 ) -> AsyncOpenAI:
     """Get an async OpenAI client instance.
 
@@ -65,6 +73,9 @@ def get_async_openai_client(
 
     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(),