unique_toolkit 1.11.2__py3-none-any.whl → 1.11.3__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/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.2.dist-info → unique_toolkit-1.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.11.2
+Version: 1.11.3
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -117,6 +117,9 @@ 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
@@ -135,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.2.dist-info → unique_toolkit-1.11.3.dist-info}/RECORD

@@ -115,6 +115,7 @@ unique_toolkit/content/constants.py,sha256=1iy4Y67xobl5VTnJB6SxSyuoBWbdLl9244xfV
 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
@@ -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.2.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.11.2.dist-info/METADATA,sha256=IdERxyqJO7c7OzqAkm1CrB5sXxC2Wu96_VAXakkjvgo,35670
-unique_toolkit-1.11.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.11.2.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,,