Skip to content

Smart Rules

The Smart Rules module provides functionality for creating and working with smart rules (UniqueQL queries) to filter and search content in the knowledge base.

Overview

Smart rules allow you to create complex queries using UniqueQL to filter and search content. They act as conditionals to reduce the amount of retrieved information by evaluating metadata of documents.

Components

Core Classes

unique_toolkit.content.smart_rules.Statement pydantic-model

Bases: BaseStatement

Show JSON schema: 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
{
  "$defs": {
    "AndStatement": {
      "properties": {
        "and": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "And",
          "type": "array"
        }
      },
      "required": [
        "and"
      ],
      "title": "AndStatement",
      "type": "object"
    },
    "Operator": {
      "enum": [
        "equals",
        "notEquals",
        "greaterThan",
        "greaterThanOrEqual",
        "lessThan",
        "lessThanOrEqual",
        "in",
        "notIn",
        "contains",
        "notContains",
        "isNull",
        "isNotNull",
        "isEmpty",
        "isNotEmpty",
        "nested"
      ],
      "title": "Operator",
      "type": "string"
    },
    "OrStatement": {
      "properties": {
        "or": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "Or",
          "type": "array"
        }
      },
      "required": [
        "or"
      ],
      "title": "OrStatement",
      "type": "object"
    },
    "Statement": {
      "properties": {
        "operator": {
          "$ref": "#/$defs/Operator"
        },
        "value": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            },
            {
              "type": "boolean"
            },
            {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            {
              "$ref": "#/$defs/AndStatement"
            },
            {
              "$ref": "#/$defs/OrStatement"
            }
          ],
          "title": "Value"
        },
        "path": {
          "items": {
            "type": "string"
          },
          "title": "Path",
          "type": "array"
        }
      },
      "required": [
        "operator",
        "value"
      ],
      "title": "Statement",
      "type": "object"
    }
  },
  "$ref": "#/$defs/Statement"
}

Fields:

Source code in unique_toolkit/unique_toolkit/content/smart_rules.py 
58
59
60
61
62
63
64
65
66
67
68
69
70
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

unique_toolkit.content.smart_rules.Operator

Bases: str, Enum

Source code in unique_toolkit/unique_toolkit/content/smart_rules.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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"

unique_toolkit.content.smart_rules.AndStatement pydantic-model

Bases: BaseStatement

Show JSON schema: 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
{
  "$defs": {
    "AndStatement": {
      "properties": {
        "and": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "And",
          "type": "array"
        }
      },
      "required": [
        "and"
      ],
      "title": "AndStatement",
      "type": "object"
    },
    "Operator": {
      "enum": [
        "equals",
        "notEquals",
        "greaterThan",
        "greaterThanOrEqual",
        "lessThan",
        "lessThanOrEqual",
        "in",
        "notIn",
        "contains",
        "notContains",
        "isNull",
        "isNotNull",
        "isEmpty",
        "isNotEmpty",
        "nested"
      ],
      "title": "Operator",
      "type": "string"
    },
    "OrStatement": {
      "properties": {
        "or": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "Or",
          "type": "array"
        }
      },
      "required": [
        "or"
      ],
      "title": "OrStatement",
      "type": "object"
    },
    "Statement": {
      "properties": {
        "operator": {
          "$ref": "#/$defs/Operator"
        },
        "value": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            },
            {
              "type": "boolean"
            },
            {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            {
              "$ref": "#/$defs/AndStatement"
            },
            {
              "$ref": "#/$defs/OrStatement"
            }
          ],
          "title": "Value"
        },
        "path": {
          "items": {
            "type": "string"
          },
          "title": "Path",
          "type": "array"
        }
      },
      "required": [
        "operator",
        "value"
      ],
      "title": "Statement",
      "type": "object"
    }
  },
  "$ref": "#/$defs/AndStatement"
}

Fields:

Source code in unique_toolkit/unique_toolkit/content/smart_rules.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
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

unique_toolkit.content.smart_rules.OrStatement pydantic-model

Bases: BaseStatement

Show JSON schema: 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
{
  "$defs": {
    "AndStatement": {
      "properties": {
        "and": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "And",
          "type": "array"
        }
      },
      "required": [
        "and"
      ],
      "title": "AndStatement",
      "type": "object"
    },
    "Operator": {
      "enum": [
        "equals",
        "notEquals",
        "greaterThan",
        "greaterThanOrEqual",
        "lessThan",
        "lessThanOrEqual",
        "in",
        "notIn",
        "contains",
        "notContains",
        "isNull",
        "isNotNull",
        "isEmpty",
        "isNotEmpty",
        "nested"
      ],
      "title": "Operator",
      "type": "string"
    },
    "OrStatement": {
      "properties": {
        "or": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/Statement"
              },
              {
                "$ref": "#/$defs/AndStatement"
              },
              {
                "$ref": "#/$defs/OrStatement"
              }
            ]
          },
          "title": "Or",
          "type": "array"
        }
      },
      "required": [
        "or"
      ],
      "title": "OrStatement",
      "type": "object"
    },
    "Statement": {
      "properties": {
        "operator": {
          "$ref": "#/$defs/Operator"
        },
        "value": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "integer"
            },
            {
              "type": "boolean"
            },
            {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            {
              "$ref": "#/$defs/AndStatement"
            },
            {
              "$ref": "#/$defs/OrStatement"
            }
          ],
          "title": "Value"
        },
        "path": {
          "items": {
            "type": "string"
          },
          "title": "Path",
          "type": "array"
        }
      },
      "required": [
        "operator",
        "value"
      ],
      "title": "Statement",
      "type": "object"
    }
  },
  "$ref": "#/$defs/OrStatement"
}

Fields:

Source code in unique_toolkit/unique_toolkit/content/smart_rules.py 
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
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

unique_toolkit.content.smart_rules.BaseStatement pydantic-model

Bases: BaseModel

Show JSON schema: 
1
2
3
4
5
{
  "properties": {},
  "title": "BaseStatement",
  "type": "object"
}

Config:

  • serialize_by_alias: True
Source code in unique_toolkit/unique_toolkit/content/smart_rules.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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()