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

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/test_utilities/events.py

@@ -0,0 +1,197 @@
+import random
+import string
+from datetime import datetime
+from typing import Any
+
+from unique_toolkit.app.schemas import (
+    BaseEvent,
+    ChatEvent,
+    ChatEventAdditionalParameters,
+    ChatEventAssistantMessage,
+    ChatEventPayload,
+    ChatEventUserMessage,
+    EventName,
+)
+from unique_toolkit.app.unique_settings import UniqueSettings
+
+
+def generated_numeric_string(length: int) -> str:
+    return "".join(random.choices(string.digits, k=length))
+
+
+def generated_alphanumeric_string(length: int) -> str:
+    return "".join(random.choices(string.ascii_letters + string.digits, k=length))
+
+
+def generated_chat_id() -> str:
+    return f"chat_{generated_alphanumeric_string(16)}"
+
+
+def generated_assistant_id() -> str:
+    return f"assistant_{generated_alphanumeric_string(16)}"
+
+
+def generated_user_message_id() -> str:
+    return f"msg_{generated_alphanumeric_string(16)}"
+
+
+class TestEventFactory:
+    """Factory for creating test event objects with sensible defaults.
+
+    Simplifies test setup by providing convenient methods to generate
+    chat events, messages, and related objects for testing.
+    """
+
+    def __init__(self, settings: UniqueSettings | None = None) -> None:
+        self._settings = settings
+
+    def _get_user_id(self) -> str:
+        if self._settings is None:
+            return generated_numeric_string(16)
+        else:
+            return self._settings.auth.user_id.get_secret_value()
+
+    def _get_company_id(self) -> str:
+        if self._settings is None:
+            return generated_numeric_string(16)
+        else:
+            return self._settings.auth.company_id.get_secret_value()
+
+    def get_chat_event_user_message(
+        self,
+        text: str,
+        *,
+        created_at: datetime | None = None,
+        language: str = "DE",
+        original_text: str | None = None,
+    ) -> ChatEventUserMessage:
+        if created_at is None:
+            created_at = datetime.now()
+
+        return ChatEventUserMessage(
+            id=generated_user_message_id(),
+            text=text,
+            original_text=original_text or text,
+            created_at=created_at.isoformat(),
+            language=language,
+        )
+
+    def get_chat_event_assistant_message(
+        self, *, created_at: datetime | None = None
+    ) -> ChatEventAssistantMessage:
+        if created_at is None:
+            created_at = datetime.now()
+
+        return ChatEventAssistantMessage(
+            id=generated_assistant_id(), created_at=created_at.isoformat()
+        )
+
+    def get_chat_event_additional_parameters(
+        self,
+        *,
+        translate_to_language: str | None = None,
+        content_id_to_translate: str | None = None,
+    ) -> ChatEventAdditionalParameters:
+        return ChatEventAdditionalParameters(
+            translate_to_language=translate_to_language,
+            content_id_to_translate=content_id_to_translate,
+        )
+
+    def get_base_event(
+        self,
+        *,
+        event: EventName = EventName.EXTERNAL_MODULE_CHOSEN,
+        user_id: str | None = None,
+        company_id: str | None = None,
+    ) -> BaseEvent:
+        return BaseEvent(
+            id=generated_alphanumeric_string(16),
+            event=event,
+            user_id=user_id or self._get_user_id(),
+            company_id=company_id or self._get_company_id(),
+        )
+
+    def get_chat_event_payload(
+        self,
+        *,
+        name: str,
+        description: str,
+        user_message_text: str,
+        user_message_created_at: datetime | None = None,
+        user_message_language: str = "DE",
+        user_message_original_text: str | None = None,
+        assistant_message_created_at: datetime | None = None,
+        configuration: dict[str, Any] | None = None,
+        chat_id: str | None = None,
+        assistant_id: str | None = None,
+    ) -> ChatEventPayload:
+        if chat_id is None:
+            chat_id = generated_chat_id()
+
+        if assistant_id is None:
+            assistant_id = generated_assistant_id()
+
+        assistant_message = self.get_chat_event_assistant_message(
+            created_at=assistant_message_created_at or datetime.now()
+        )
+        user_message = self.get_chat_event_user_message(
+            text=user_message_text,
+            created_at=user_message_created_at or datetime.now(),
+            language=user_message_language,
+            original_text=user_message_original_text,
+        )
+        return ChatEventPayload(
+            name=name,
+            description=description,
+            configuration=configuration or {},
+            chat_id=chat_id,
+            assistant_id=assistant_id,
+            user_message=user_message,
+            assistant_message=assistant_message,
+        )
+
+    def get_chat_event(
+        self,
+        *,
+        name: str,
+        event_name: EventName = EventName.EXTERNAL_MODULE_CHOSEN,
+        description: str,
+        user_message_text: str,
+        user_message_created_at: datetime = datetime.now(),
+        user_message_language: str = "DE",
+        user_message_original_text: str | None = None,
+        assistant_message_created_at: datetime | None = None,
+        configuration: dict[str, Any] | None = None,
+        chat_id: str | None = None,
+        assistant_id: str | None = None,
+        user_id: str | None = None,
+        company_id: str | None = None,
+        version: str = "1.0",
+    ) -> ChatEvent:
+        if chat_id is None:
+            chat_id = generated_chat_id()
+
+        if assistant_id is None:
+            assistant_id = generated_assistant_id()
+
+        payload = self.get_chat_event_payload(
+            name=name,
+            description=description,
+            user_message_text=user_message_text,
+            user_message_created_at=user_message_created_at,
+            user_message_language=user_message_language,
+            user_message_original_text=user_message_original_text,
+            assistant_message_created_at=assistant_message_created_at,
+            configuration=configuration or {},
+            chat_id=chat_id,
+            assistant_id=assistant_id,
+        )
+        return ChatEvent(
+            id=generated_alphanumeric_string(16),
+            event=event_name,
+            user_id=user_id or self._get_user_id(),
+            company_id=company_id or self._get_company_id(),
+            payload=payload,
+            created_at=int(datetime.now().timestamp()),
+            version=version,
+        )