unique_toolkit 1.11.1__py3-none-any.whl → 1.11.3__py3-none-any.whl

unique_toolkit/content/functions.py

@@ -16,7 +16,8 @@ from unique_toolkit.content.schemas import (
     ContentInfo,
     ContentRerankerConfig,
     ContentSearchType,
-    PaginatedContentInfo,
+    FolderInfo,
+    PaginatedContentInfos,
 )
 from unique_toolkit.content.utils import map_contents, map_to_content_chunks
 
@@ -590,21 +591,33 @@ def get_content_info(
     file_path: str | None = None,
 ):
     """Gets the info of a content."""
+
     get_info_params = unique_sdk.Content.ContentInfoParams(
-        metadataFilter=metadata_filter,
-        skip=skip,
-        take=take,
-        filePath=file_path,
+        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_info(
+    content_info = unique_sdk.Content.get_infos(
         user_id=user_id, company_id=company_id, **get_info_params
     )
-    return PaginatedContentInfo.model_validate(
+    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,

unique_toolkit/content/schemas.py

@@ -154,12 +154,13 @@ class ContentRerankerConfig(BaseModel):
 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
-    mime_type: str
     byte_size: int
+    mime_type: str
     owner_id: str
     created_at: datetime
     updated_at: datetime
@@ -168,7 +169,19 @@ class ContentInfo(BaseModel):
     expired_at: datetime | None = None
 
 
-class PaginatedContentInfo(BaseModel):
+class PaginatedContentInfos(BaseModel):
     model_config = model_config
-    content_info: list[ContentInfo]
+    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

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/knowledge_base.py

@@ -14,6 +14,7 @@ from unique_toolkit.content.functions import (
     download_content_to_bytes,
     download_content_to_file_by_id,
     get_content_info,
+    get_folder_info,
     search_content_chunks,
     search_content_chunks_async,
     search_contents,
@@ -28,7 +29,8 @@ from unique_toolkit.content.schemas import (
     ContentInfo,
     ContentRerankerConfig,
     ContentSearchType,
-    PaginatedContentInfo,
+    FolderInfo,
+    PaginatedContentInfos,
 )
 
 _LOGGER = logging.getLogger(f"toolkit.knowledge_base.{__name__}")
@@ -483,7 +485,7 @@ class KnowledgeBaseService:
         skip: int | None = None,
         take: int | None = None,
         file_path: str | None = None,
-    ) -> PaginatedContentInfo:
+    ) -> PaginatedContentInfos:
         return get_content_info(
             user_id=self._user_id,
             company_id=self._company_id,
@@ -493,6 +495,17 @@ class KnowledgeBaseService:
             file_path=file_path,
         )
 
+    def get_folder_info(
+        self,
+        *,
+        scope_id: str,
+    ) -> FolderInfo:
+        return get_folder_info(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            scope_id=scope_id,
+        )
+
     def replace_content_metadata(
         self,
         *,
@@ -506,6 +519,72 @@ class KnowledgeBaseService:
             metadata=metadata,
         )
 
+    def _resolve_visible_file_tree(self, content_infos: list[ContentInfo]) -> list[str]:
+        # collect all scope ids
+        folder_id_paths: set[str] = set()
+        known_folder_paths: set[str] = set()
+        for content_info in content_infos:
+            if (
+                content_info.metadata
+                and content_info.metadata.get(r"{FullPath}") is not None
+            ):
+                known_folder_paths.add(str(content_info.metadata.get(r"{FullPath}")))
+                continue
+
+            if (
+                content_info.metadata
+                and content_info.metadata.get("folderIdPath") is not None
+            ):
+                folder_id_paths.add(str(content_info.metadata.get("folderIdPath")))
+
+        scope_ids: set[str] = set()
+        for fp in folder_id_paths:
+            scope_ids_list = set(fp.replace("uniquepathid://", "").split("/"))
+            scope_ids.update(scope_ids_list)
+
+        scope_id_to_folder_name: dict[str, str] = {}
+        for scope_id in scope_ids:
+            folder_info = self.get_folder_info(
+                scope_id=scope_id,
+            )
+            scope_id_to_folder_name[scope_id] = folder_info.name
+
+        folder_paths: set[str] = set()
+        for folder_id_path in folder_id_paths:
+            scope_ids_list = folder_id_path.replace("uniquepathid://", "").split("/")
+
+            if all(scope_id in scope_id_to_folder_name for scope_id in scope_ids_list):
+                folder_path = [
+                    scope_id_to_folder_name[scope_id] for scope_id in scope_ids_list
+                ]
+                folder_paths.add("/".join(folder_path))
+
+        return [
+            p if p.startswith("/") else f"/{p}"
+            for p in folder_paths.union(known_folder_paths)
+        ]
+
+    def resolve_visible_file_tree(
+        self, *, metadata_filter: dict[str, Any] | None = None
+    ) -> list[str]:
+        """
+        Resolves the visible file tree for the knowledge base for the current user.
+
+        Args:
+            metadata_filter (dict[str, Any] | None): The metadata filter to use. Defaults to None.
+
+        Returns:
+            list[str]: The visible file tree.
+
+
+
+        """
+        info = self.get_paginated_content_infos(
+            metadata_filter=metadata_filter,
+        )
+
+        return self._resolve_visible_file_tree(content_infos=info.content_infos)
+
 
 if __name__ == "__main__":
     kb_service = KnowledgeBaseService.from_settings()

unique_toolkit/smart_rules/compile.py

@@ -1,301 +1,56 @@
-import re
-from datetime import datetime, timedelta, timezone
-from enum import Enum
-from typing import Any, Dict, List, 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: Dict[str, Union[str, int, bool]],
-        tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-        tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-        tool_parameters: Dict[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(
-        alias="and", validation_alias=AliasChoices("and", "and_list")
-    )
-
-    def _fill_in_variables(
-        self,
-        user_metadata: Dict[str, Union[str, int, bool]],
-        tool_parameters: Dict[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(
-        alias="or", validation_alias=AliasChoices("or", "or_list")
-    )
-
-    def _fill_in_variables(
-        self,
-        user_metadata: Dict[str, Union[str, int, bool]],
-        tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[str, Union[str, int, bool]],
-) -> Any:
-    return replace_variables(value, user_metadata, tool_parameters)
-
-
-def array_operator(
-    value: Any,
-    user_metadata: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[str, Union[str, int, bool]],
-) -> Any:
-    return value  # do nothing for now. No variables to replace
-
-
-def empty_operator(
-    operator: Operator,
-    user_metadata: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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: Dict[str, Union[str, int, bool]],
-    tool_parameters: Dict[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")
+import warnings
+
+from unique_toolkit.content.smart_rules import (
+    AndStatement,
+    BaseStatement,
+    Operator,
+    OrStatement,
+    Statement,
+    UniqueQL,
+    array_operator,
+    binary_operator,
+    calculate_current_date,
+    calculate_earlier_date,
+    calculate_later_date,
+    empty_operator,
+    eval_nested_operator,
+    eval_operator,
+    get_fallback_values,
+    is_array_of_strings,
+    null_operator,
+    parse_uniqueql,
+    replace_tool_parameters_patterns,
+    replace_user_metadata_patterns,
+    replace_variables,
+)
+
+warnings.warn(
+    "unique_toolkit.smart_rules.compile is deprecated. "
+    "Please use unique_toolkit.content.smart_rules instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+__all__ = [
+    "AndStatement",
+    "BaseStatement",
+    "Operator",
+    "OrStatement",
+    "Statement",
+    "UniqueQL",
+    "array_operator",
+    "binary_operator",
+    "calculate_current_date",
+    "calculate_earlier_date",
+    "calculate_later_date",
+    "empty_operator",
+    "eval_nested_operator",
+    "eval_operator",
+    "get_fallback_values",
+    "is_array_of_strings",
+    "null_operator",
+    "parse_uniqueql",
+    "replace_tool_parameters_patterns",
+    "replace_user_metadata_patterns",
+    "replace_variables",
+]

{unique_toolkit-1.11.1.dist-info → unique_toolkit-1.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.11.1
+Version: 1.11.3
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -117,6 +117,12 @@ 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).
+## [1.11.3] - 2026-10-06
+- Move smart rules to content
+- Add to documentation
+
+## [1.11.2] - 2025-10-07
+- Fix for empty metadata filter at info retrieval
 
 ## [1.11.1] - 2025-10-07
 - Fix bug where hallucination check was taking all of the chunks as input instead of only the referenced ones.
@@ -132,6 +138,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [1.9.1] - 2025-10-06
 - Switch default model used in evaluation service from `GPT-3.5-turbo (0125)` to `GPT-4o (1120)`
 
+
 ## [1.9.0] - 2026-10-04
 - Define the RequestContext and add aihttp/httpx requestors
 

{unique_toolkit-1.11.1.dist-info → unique_toolkit-1.11.3.dist-info}/RECORD

@@ -112,9 +112,10 @@ unique_toolkit/chat/state.py,sha256=Cjgwv_2vhDFbV69xxsn7SefhaoIAEqLx3ferdVFCnOg,
 unique_toolkit/chat/utils.py,sha256=ihm-wQykBWhB4liR3LnwPVPt_qGW6ETq21Mw4HY0THE,854
 unique_toolkit/content/__init__.py,sha256=EdJg_A_7loEtCQf4cah3QARQreJx6pdz89Rm96YbMVg,940
 unique_toolkit/content/constants.py,sha256=1iy4Y67xobl5VTnJB6SxSyuoBWbdLl9244xfVMUZi5o,60
-unique_toolkit/content/functions.py,sha256=culiG7WLAaxo1FnSOdpavwWLybk9Z0vHVZYlMrYLGXI,20678
-unique_toolkit/content/schemas.py,sha256=mhPMPD5VYxFJ2F2AVjaUXXJSkcDgIDj26mMt8p7L5FU,5315
+unique_toolkit/content/functions.py,sha256=6Z9fOEsngJaT1R5DgoeRl5z06RavYgCxiAAPjkw-NKI,21100
+unique_toolkit/content/schemas.py,sha256=YmZa6ddjf6_RvDFGPovamLd0YX99am9nzWYrKHo8-Hg,5579
 unique_toolkit/content/service.py,sha256=i7wN_wYjF8NBZHBcpcA5XRlMRGntuw3mlVoudAoGQRk,23293
+unique_toolkit/content/smart_rules.py,sha256=z2gHToPrdyj3HqO8Uu-JE5G2ClvJPuhR2XERmmkgoug,9668
 unique_toolkit/content/utils.py,sha256=qNVmHTuETaPNGqheg7TbgPr1_1jbNHDc09N5RrmUIyo,7901
 unique_toolkit/embedding/__init__.py,sha256=uUyzjonPvuDCYsvXCIt7ErQXopLggpzX-MEQd3_e2kE,250
 unique_toolkit/embedding/constants.py,sha256=Lj8-Lcy1FvuC31PM9Exq7vaFuxQV4pEI1huUMFX-J2M,52
@@ -129,7 +130,7 @@ unique_toolkit/framework_utilities/openai/__init__.py,sha256=CrHYoC7lv2pBscitLer
 unique_toolkit/framework_utilities/openai/client.py,sha256=ct1cqPcIK1wPl11G9sJV39ZnLJwKr2kDUDSra0FjvtM,2007
 unique_toolkit/framework_utilities/openai/message_builder.py,sha256=VU6mJm_upLcarJQKFft_t1RlLRncWDxDuLC5LIJ5lQQ,4339
 unique_toolkit/framework_utilities/utils.py,sha256=JK7g2yMfEx3eMprug26769xqNpS5WJcizf8n2zWMBng,789
-unique_toolkit/knowledge_base.py,sha256=cx_Us1-a8aXMHCd9bWuW8bkDiQ52Qvty_97SKGdMDfc,17519
+unique_toolkit/knowledge_base.py,sha256=SHAFs68zDQuHJZdrFcdU7wnkUdfNQlNzpSLNckx3Scg,20167
 unique_toolkit/language_model/__init__.py,sha256=lRQyLlbwHbNFf4-0foBU13UGb09lwEeodbVsfsSgaCk,1971
 unique_toolkit/language_model/builder.py,sha256=4OKfwJfj3TrgO1ezc_ewIue6W7BCQ2ZYQXUckWVPPTA,3369
 unique_toolkit/language_model/constants.py,sha256=B-topqW0r83dkC_25DeQfnPk3n53qzIHUCBS7YJ0-1U,119
@@ -147,8 +148,8 @@ unique_toolkit/short_term_memory/functions.py,sha256=3WiK-xatY5nh4Dr5zlDUye1k3E6
 unique_toolkit/short_term_memory/schemas.py,sha256=OhfcXyF6ACdwIXW45sKzjtZX_gkcJs8FEZXcgQTNenw,1406
 unique_toolkit/short_term_memory/service.py,sha256=5PeVBu1ZCAfyDb2HLVvlmqSbyzBBuE9sI2o9Aajqjxg,8884
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-unique_toolkit/smart_rules/compile.py,sha256=cxWjb2dxEI2HGsakKdVCkSNi7VK9mr08w5sDcFCQyWI,9553
-unique_toolkit-1.11.1.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.11.1.dist-info/METADATA,sha256=PA3FkNO1TYXrN7GCWX1PWEyRZXp6hK3zXEiTCQZV9j0,35594
-unique_toolkit-1.11.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.11.1.dist-info/RECORD,,
+unique_toolkit/smart_rules/compile.py,sha256=Ozhh70qCn2yOzRWr9d8WmJeTo7AQurwd3tStgBMPFLA,1246
+unique_toolkit-1.11.3.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-1.11.3.dist-info/METADATA,sha256=bc9ld0sdYyiytQL4O7lba5xUSLJb5XtkzoWts984bi4,35749
+unique_toolkit-1.11.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-1.11.3.dist-info/RECORD,,