orchestrator-core 4.4.2__py3-none-any.whl → 4.5.0__py3-none-any.whl

orchestrator/search/core/validators.py

@@ -0,0 +1,40 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import uuid
+
+from dateutil.parser import isoparse
+
+
+def is_uuid(value: str) -> bool:
+    """Check if a string is a valid UUID."""
+    try:
+        uuid.UUID(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def is_iso_date(value: str) -> bool:
+    """Check if a string is a valid ISO 8601 date."""
+    try:
+        isoparse(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def is_bool_string(value: str) -> bool:
+    """Check if a string explicitly represents a boolean value with true/false."""
+
+    return value.strip().lower() in {"true", "false"}

orchestrator/search/docs/index.md

@@ -0,0 +1,37 @@
+# Search Indexing CLI
+
+Typer-based CLI for maintaining search indexes (subscriptions, products, processes, workflows).
+
+## Usage
+
+Run from project root:
+
+```
+dotenv run python main.py index [COMMAND] [OPTIONS]
+```
+
+### Commands
+
+- `subscriptions` – index `subscription_search_index`
+- `products` – index `product_search_index`
+- `processes` – index `process_search_index`
+- `workflows` – index `workflow_search_index`
+
+### Options
+
+- `--<id>` – UUID of a specific entity (default: all)
+- `--dry-run` – no DB writes
+- `--force-index` – re-index even if unchanged
+
+### Examples
+
+```
+# Index all subscriptions
+dotenv run python main.py index subscriptions
+
+# Re-index all subscriptions
+dotenv run python main.py index subscriptions --force-index
+
+# Index a single subscription
+dotenv run python main.py index subscriptions --subscription-id=<UUID>
+```

orchestrator/search/docs/running_local_text_embedding_inference.md

@@ -0,0 +1,46 @@
+# Running a local MiniLM embedding server with Hugging Face TEI
+
+Only **OpenAI-compatible endpoints** are supported locally.
+
+You can spin up a embedding API based on **sentence-transformers/all-MiniLM-L6-v2** using [Hugging Face TEI](https://github.com/huggingface/text-embeddings-inference):
+
+```bash
+docker run --rm -p 8080:80 ghcr.io/huggingface/text-embeddings-inference:cpu-1.8 \
+    --model-id sentence-transformers/all-MiniLM-L6-v2
+```
+
+---
+
+## Environment variables
+
+Point your backend to the local endpoint and declare the new vector size:
+
+```env
+OPENAI_BASE_URL=http://localhost:8080/v1
+EMBEDDING_DIMENSION=384
+EMBEDDING_MAX_BATCH_SIZE=32 # Not required when using OpenAI embeddings
+```
+
+Depending on the model, you might want to change the `EMBEDDING_FALLBACK_MAX_TOKENS` and `EMBEDDING_MAX_BATCH_SIZE` settings, which are set conservatively and according to the requirements of the setup used in this example.
+
+---
+
+## Apply the schema change
+
+With these new settings run:
+
+```bash
+dotenv run python main.py embedding resize
+```
+
+**Note** that this will delete all records and you will have to re-index.
+
+---
+
+## Re-index embeddings
+
+```bash
+dotenv run python main.py index subscriptions
+```
+
+The search index now uses **384-dimension MiniLM vectors** served from your local Docker container. That’s it! 🚀

orchestrator/search/filters/__init__.py

@@ -0,0 +1,40 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .base import (
+    EqualityFilter,
+    FilterCondition,
+    FilterTree,
+    PathFilter,
+    StringFilter,
+)
+from .date_filters import DateFilter, DateRangeFilter, DateValueFilter
+from .ltree_filters import LtreeFilter
+from .numeric_filter import NumericFilter, NumericRangeFilter, NumericValueFilter
+
+__all__ = [
+    # Base filter classes
+    "PathFilter",
+    "FilterTree",
+    "FilterCondition",
+    "StringFilter",
+    "EqualityFilter",
+    # Filters for specific value types
+    "NumericValueFilter",
+    "NumericRangeFilter",
+    "DateValueFilter",
+    "DateRangeFilter",
+    "DateFilter",
+    "LtreeFilter",
+    "NumericFilter",
+]

orchestrator/search/filters/base.py

@@ -0,0 +1,295 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from itertools import count
+from typing import Any, ClassVar, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from sqlalchemy import BinaryExpression, and_, cast, exists, literal, or_, select
+from sqlalchemy.dialects.postgresql import BOOLEAN
+from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy_utils.types.ltree import Ltree
+
+from orchestrator.db.models import AiSearchIndex
+from orchestrator.search.core.types import BooleanOperator, FieldType, FilterOp, SQLAColumn, UIType
+
+from .date_filters import DateFilter
+from .ltree_filters import LtreeFilter
+from .numeric_filter import NumericFilter
+
+
+class EqualityFilter(BaseModel):
+    op: Literal[FilterOp.EQ, FilterOp.NEQ]
+    value: Any
+
+    def to_expression(self, column: SQLAColumn, path: str) -> BinaryExpression[bool] | ColumnElement[bool]:
+        if isinstance(self.value, bool):
+            colb = cast(column, BOOLEAN)
+            return colb.is_(self.value) if self.op == FilterOp.EQ else ~colb.is_(self.value)
+        sv = str(self.value)
+        return (column == sv) if self.op == FilterOp.EQ else (column != sv)
+
+
+class StringFilter(BaseModel):
+    op: Literal[FilterOp.LIKE]
+    value: str
+
+    def to_expression(self, column: SQLAColumn, path: str) -> ColumnElement[bool]:
+        return column.like(self.value)
+
+    @model_validator(mode="after")
+    def validate_like_pattern(self) -> StringFilter:
+        """If the operation is 'like', the value must contain a wildcard."""
+        if self.op == FilterOp.LIKE:
+            if "%" not in self.value and "_" not in self.value:
+                raise ValueError("The value for a 'like' operation must contain a wildcard character ('%' or '_').")
+        return self
+
+
+# Order matters! Ambiguous ops (like 'eq') are resolved by first matching filter
+FilterCondition = (
+    DateFilter  # DATETIME
+    | NumericFilter  # INT/FLOAT
+    | StringFilter  # STRING TODO: convert to hybrid search?
+    | LtreeFilter  # Path
+    | EqualityFilter  # BOOLEAN/UUID/BLOCK/RESOURCE_TYPE - most generic, try last
+)
+
+
+class PathFilter(BaseModel):
+
+    path: str = Field(description="The ltree path of the field to filter on, e.g., 'subscription.customer_id'.")
+    condition: FilterCondition = Field(description="The filter condition to apply.")
+
+    value_kind: UIType
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "examples": [
+                {"path": "subscription.status", "condition": {"op": "eq", "value": "active"}, "value_kind": "string"},
+                {
+                    "path": "subscription.customer_id",
+                    "condition": {"op": "neq", "value": "acme"},
+                    "value_kind": "string",
+                },
+                {
+                    "path": "subscription.start_date",
+                    "condition": {"op": "gt", "value": "2025-01-01"},
+                    "value_kind": "datetime",
+                },
+                {
+                    "path": "subscription.end_date",
+                    "condition": {
+                        "op": "between",
+                        "value": {"start": "2025-06-01", "end": "2025-07-01"},
+                    },
+                    "value_kind": "datetime",
+                },
+                {
+                    "path": "subscription",
+                    "condition": {"op": "has_component", "value": "node"},
+                    "value_kind": "component",
+                },
+            ]
+        }
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _transfer_path_to_value_if_needed(cls, data: Any) -> Any:
+        """Transform for path-only filters.
+
+        If `op` is `has_component`, `not_has_component`, or `ends_with` and no `value` is
+        provided in the `condition`, this validator will automatically use the `path`
+        field as the `value` and set the `path` to a wildcard '*' for the query.
+        """
+        if isinstance(data, dict):
+            path = data.get("path")
+            condition = data.get("condition")
+
+            if path and isinstance(condition, dict):
+                op = condition.get("op")
+                value = condition.get("value")
+
+                path_only_ops = [FilterOp.HAS_COMPONENT, FilterOp.NOT_HAS_COMPONENT, FilterOp.ENDS_WITH]
+
+                if op in path_only_ops and value is None:
+                    condition["value"] = path
+                    data["path"] = "*"
+        return data
+
+    def to_expression(self, value_column: SQLAColumn, value_type_column: SQLAColumn) -> ColumnElement[bool]:
+        """Convert the path filter into a SQLAlchemy expression with type safety.
+
+        This method creates a type guard to ensure we only match compatible field types,
+        then delegates to the specific filter condition.
+
+        Args:
+            value_column (ColumnElement): The SQLAlchemy column element representing the value to be filtered.
+            value_type_column (ColumnElement): The SQLAlchemy column element representing the field type.
+
+        Returns:
+            ColumnElement[bool]: A SQLAlchemy boolean expression that can be used in a ``WHERE`` clause.
+        """
+
+        # Type guard - only match compatible field types
+        allowed_field_types = [ft.value for ft in FieldType if UIType.from_field_type(ft) == self.value_kind]
+        type_guard = value_type_column.in_(allowed_field_types) if allowed_field_types else literal(True)
+
+        return and_(type_guard, self.condition.to_expression(value_column, self.path))
+
+
+class FilterTree(BaseModel):
+    op: BooleanOperator = Field(
+        description="Operator for grouping conditions in uppercase.", default=BooleanOperator.AND
+    )
+
+    children: list[FilterTree | PathFilter] = Field(min_length=1, description="Path filters or nested groups.")
+
+    MAX_DEPTH: ClassVar[int] = 5
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "description": (
+                "Boolean filter tree. Operators must be UPPERCASE: AND / OR.\n"
+                "Node shapes:\n"
+                "  • Group: {'op':'AND'|'OR', 'children': [<PathFilter|FilterTree>, ...]}\n"
+                "  • Leaf (PathFilter): {'path':'<ltree>', 'condition': {...}}\n"
+                "Rules:\n"
+                "  • Do NOT put 'op' or 'children' inside a leaf 'condition'.\n"
+                f"  • Max depth = {MAX_DEPTH}.\n"
+            ),
+            "examples": [
+                {
+                    "description": "Simple filters",
+                    "op": "AND",
+                    "children": [
+                        {"path": "subscription.status", "condition": {"op": "eq", "value": "active"}},
+                        {"path": "subscription.start_date", "condition": {"op": "gt", "value": "2021-01-01"}},
+                    ],
+                },
+                {
+                    "description": "Complex filters with OR group",
+                    "op": "AND",
+                    "children": [
+                        {"path": "subscription.start_date", "condition": {"op": "gte", "value": "2024-01-01"}},
+                        {
+                            "op": "OR",
+                            "children": [
+                                {"path": "subscription.product.name", "condition": {"op": "like", "value": "%fiber%"}},
+                                {"path": "subscription.customer_id", "condition": {"op": "eq", "value": "Surf"}},
+                            ],
+                        },
+                    ],
+                },
+            ],
+        }
+    )
+
+    @model_validator(mode="after")
+    def _validate_depth(self) -> FilterTree:
+        def depth(node: "FilterTree | PathFilter") -> int:
+            return 1 + max(depth(c) for c in node.children) if isinstance(node, FilterTree) else 1
+
+        if depth(self) > self.MAX_DEPTH:
+            raise ValueError(f"FilterTree nesting exceeds MAX_DEPTH={self.MAX_DEPTH}")
+        return self
+
+    @classmethod
+    def from_flat_and(cls, filters: list[PathFilter]) -> FilterTree | None:
+        """Wrap a flat list of PathFilter into an AND group (or None)."""
+        return None if not filters else cls(op=BooleanOperator.AND, children=list(filters))
+
+    def get_all_paths(self) -> set[str]:
+        """Collects all unique paths from the PathFilter leaves in the tree."""
+        return {leaf.path for leaf in self.get_all_leaves()}
+
+    def get_all_leaves(self) -> list[PathFilter]:
+        """Collect all PathFilter leaves in the tree."""
+        leaves: list[PathFilter] = []
+        for child in self.children:
+            if isinstance(child, PathFilter):
+                leaves.append(child)
+            else:
+                leaves.extend(child.get_all_leaves())
+        return leaves
+
+    @staticmethod
+    def _build_correlates(
+        alias: Any, entity_id_col: SQLAColumn, entity_type_value: str | None
+    ) -> list[ColumnElement[bool]]:
+        """Build the correlation predicates that link the subquery to the outer query."""
+        correlates = [alias.entity_id == entity_id_col]
+        if entity_type_value is not None:
+            correlates.append(alias.entity_type == entity_type_value)
+        return correlates
+
+    @staticmethod
+    def _handle_ltree_filter(pf: PathFilter, alias: Any, correlates: list[ColumnElement[bool]]) -> ColumnElement[bool]:
+        """Handle path-only filters (has_component, not_has_component, ends_with)."""
+        # row-level predicate is always positive
+        positive = pf.condition.to_expression(alias.path, pf.path)
+        subq = select(1).select_from(alias).where(and_(*correlates, positive))
+        if pf.condition.op == FilterOp.NOT_HAS_COMPONENT:
+            return ~exists(subq)  # NOT at the entity level
+        return exists(subq)
+
+    @staticmethod
+    def _handle_value_filter(pf: PathFilter, alias: Any, correlates: list[ColumnElement[bool]]) -> ColumnElement[bool]:
+        """Handle value-based filters (equality, comparison, etc)."""
+        if "." not in pf.path:
+            path_pred = LtreeFilter(op=FilterOp.ENDS_WITH, value=pf.path).to_expression(alias.path, "")
+        else:
+            path_pred = alias.path == Ltree(pf.path)
+
+        value_pred = pf.to_expression(alias.value, alias.value_type)
+        subq = select(1).select_from(alias).where(and_(*correlates, path_pred, value_pred))
+        return exists(subq)
+
+    def to_expression(
+        self,
+        entity_id_col: SQLAColumn,
+        *,
+        entity_type_value: str | None = None,
+    ) -> ColumnElement[bool]:
+        """Compile this tree into a SQLAlchemy boolean expression.
+
+        Args:
+            entity_id_col (SQLAColumn): Column in the outer query representing the entity ID.
+            entity_type_value (str, optional): If provided, each subquery is additionally constrained to this entity type.
+
+        Returns:
+            ColumnElement[bool]: A SQLAlchemy expression suitable for use in a WHERE clause.
+        """
+        from sqlalchemy.orm import aliased
+
+        alias_idx = count(1)
+
+        def leaf_exists(pf: PathFilter) -> ColumnElement[bool]:
+            """Convert a PathFilter into an EXISTS subquery."""
+            alias = aliased(AiSearchIndex, name=f"flt_{next(alias_idx)}")
+            correlates = self._build_correlates(alias, entity_id_col, entity_type_value)
+
+            if isinstance(pf.condition, LtreeFilter):
+                return self._handle_ltree_filter(pf, alias, correlates)
+            return self._handle_value_filter(pf, alias, correlates)
+
+        def compile_node(node: FilterTree | PathFilter) -> ColumnElement[bool]:
+            if isinstance(node, FilterTree):
+                compiled = [compile_node(ch) for ch in node.children]
+                return and_(*compiled) if node.op == BooleanOperator.AND else or_(*compiled)
+            return leaf_exists(node)
+
+        return compile_node(self)

orchestrator/search/filters/date_filters.py

@@ -0,0 +1,88 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import date, datetime
+from typing import Annotated, Any, Literal
+
+from dateutil.parser import parse as dt_parse
+from pydantic import BaseModel, BeforeValidator, Field, model_validator
+from sqlalchemy import TIMESTAMP, and_
+from sqlalchemy import cast as sa_cast
+from sqlalchemy.sql.elements import ColumnElement
+
+from orchestrator.search.core.types import FilterOp, SQLAColumn
+
+
+def _validate_date_string(v: Any) -> Any:
+    if not isinstance(v, str):
+        return v
+    try:
+        dt_parse(v)
+        return v
+    except Exception as exc:
+        raise ValueError("is not a valid date or datetime string") from exc
+
+
+DateValue = datetime | date | str
+ValidatedDateValue = Annotated[DateValue, BeforeValidator(_validate_date_string)]
+
+
+class DateRange(BaseModel):
+
+    start: ValidatedDateValue
+    end: ValidatedDateValue
+
+    @model_validator(mode="after")
+    def _order(self) -> "DateRange":
+        to_datetime = dt_parse(str(self.end))
+        from_datetime = dt_parse(str(self.start))
+        if to_datetime <= from_datetime:
+            raise ValueError("'to' must be after 'from'")
+        return self
+
+
+class DateValueFilter(BaseModel):
+    """A filter that operates on a single date value."""
+
+    op: Literal[FilterOp.EQ, FilterOp.NEQ, FilterOp.LT, FilterOp.LTE, FilterOp.GT, FilterOp.GTE]
+    value: ValidatedDateValue
+
+    def to_expression(self, column: SQLAColumn, path: str) -> ColumnElement[bool]:
+        date_column = sa_cast(column, TIMESTAMP(timezone=True))
+        match self.op:
+            case FilterOp.EQ:
+                return date_column == self.value
+            case FilterOp.NEQ:
+                return date_column != self.value
+            case FilterOp.LT:
+                return date_column < self.value
+            case FilterOp.LTE:
+                return date_column <= self.value
+            case FilterOp.GT:
+                return date_column > self.value
+            case FilterOp.GTE:
+                return date_column >= self.value
+
+
+class DateRangeFilter(BaseModel):
+    """A filter that operates on a range of dates."""
+
+    op: Literal[FilterOp.BETWEEN]
+    value: DateRange
+
+    def to_expression(self, column: SQLAColumn, path: str) -> ColumnElement[bool]:
+        date_column = sa_cast(column, TIMESTAMP(timezone=True))
+        return and_(date_column >= self.value.start, date_column < self.value.end)
+
+
+DateFilter = Annotated[DateValueFilter | DateRangeFilter, Field(discriminator="op")]

orchestrator/search/filters/definitions.py

@@ -0,0 +1,107 @@
+# Copyright 2019-2025 SURF, GÉANT.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from orchestrator.search.core.types import FieldType, FilterOp, UIType
+from orchestrator.search.schemas.results import TypeDefinition, ValueSchema
+
+
+def operators_for(ft: FieldType) -> list[FilterOp]:
+    """Return the list of valid operators for a given FieldType."""
+    return list(value_schema_for(ft).keys())
+
+
+def component_operators() -> dict[FilterOp, ValueSchema]:
+    """Return operators available for path components."""
+    return {
+        FilterOp.HAS_COMPONENT: ValueSchema(kind=UIType.COMPONENT),
+        FilterOp.NOT_HAS_COMPONENT: ValueSchema(kind=UIType.COMPONENT),
+    }
+
+
+def value_schema_for(ft: FieldType) -> dict[FilterOp, ValueSchema]:
+    """Return the value schema map for a given FieldType."""
+    if ft in (FieldType.INTEGER, FieldType.FLOAT):
+        return {
+            FilterOp.EQ: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.NEQ: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.LT: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.LTE: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.GT: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.GTE: ValueSchema(kind=UIType.NUMBER),
+            FilterOp.BETWEEN: ValueSchema(
+                kind="object",
+                fields={
+                    "start": ValueSchema(kind=UIType.NUMBER),
+                    "end": ValueSchema(kind=UIType.NUMBER),
+                },
+            ),
+        }
+
+    if ft == FieldType.BOOLEAN:
+        return {
+            FilterOp.EQ: ValueSchema(kind=UIType.BOOLEAN),
+            FilterOp.NEQ: ValueSchema(kind=UIType.BOOLEAN),
+        }
+
+    if ft == FieldType.DATETIME:
+        return {
+            FilterOp.EQ: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.NEQ: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.LT: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.LTE: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.GT: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.GTE: ValueSchema(kind=UIType.DATETIME),
+            FilterOp.BETWEEN: ValueSchema(
+                kind="object",
+                fields={
+                    "start": ValueSchema(kind=UIType.DATETIME),
+                    "end": ValueSchema(kind=UIType.DATETIME),
+                },
+            ),
+        }
+
+    return {
+        FilterOp.EQ: ValueSchema(kind=UIType.STRING),
+        FilterOp.NEQ: ValueSchema(kind=UIType.STRING),
+        FilterOp.LIKE: ValueSchema(kind=UIType.STRING),
+    }
+
+
+def generate_definitions() -> dict[UIType, TypeDefinition]:
+    """Generate the full definitions dictionary for all UI types."""
+    definitions: dict[UIType, TypeDefinition] = {}
+
+    for ui_type in UIType:
+        if ui_type == UIType.COMPONENT:
+            # Special case for component filtering
+            comp_ops = component_operators()
+            definitions[ui_type] = TypeDefinition(
+                operators=list(comp_ops.keys()),
+                value_schema=comp_ops,
+            )
+        else:
+            # Regular field types
+            if ui_type == UIType.NUMBER:
+                rep_ft = FieldType.INTEGER
+            elif ui_type == UIType.DATETIME:
+                rep_ft = FieldType.DATETIME
+            elif ui_type == UIType.BOOLEAN:
+                rep_ft = FieldType.BOOLEAN
+            else:
+                rep_ft = FieldType.STRING
+
+            definitions[ui_type] = TypeDefinition(
+                operators=operators_for(rep_ft),
+                value_schema=value_schema_for(rep_ft),
+            )
+    return definitions