unique_toolkit 1.40.0__py3-none-any.whl → 1.41.0__py3-none-any.whl

unique_toolkit/agentic/evaluation/hallucination/utils.py

@@ -1,4 +1,5 @@
 import logging
+from enum import StrEnum
 from string import Template
 
 from unique_toolkit.agentic.evaluation.config import EvaluationMetricConfig
@@ -9,6 +10,7 @@ from unique_toolkit.agentic.evaluation.schemas import (
     EvaluationMetricName,
     EvaluationMetricResult,
 )
+from unique_toolkit.content import ContentReference
 from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
@@ -201,13 +203,58 @@ def _get_user_prompt_default(config: EvaluationMetricConfig):
     )
 
 
+class SourceSelectionMode(StrEnum):
+    FROM_IDS = "FROM_IDS"
+    FROM_ORDER = "FROM_ORDER"
+
+
 def context_text_from_stream_response(
-    response: LanguageModelStreamResponse, selected_chunks: list[ContentChunk]
+    response: LanguageModelStreamResponse,
+    selected_chunks: list[ContentChunk],
+    source_selection_mode: SourceSelectionMode = SourceSelectionMode.FROM_IDS,
 ):
     response_references = response.message.references
-    reference_ids = [reference.source_id for reference in response_references]
-    filtered_contexts: list[str] = []
-    for chunk in selected_chunks:
-        if f"{chunk.id}_{chunk.chunk_id}" in reference_ids:
-            filtered_contexts.append(chunk.text)
-    return filtered_contexts
+    match source_selection_mode:
+        case SourceSelectionMode.FROM_IDS:
+            referenced_chunks = _default_source_selection_mode(
+                response_references, selected_chunks
+            )
+        case SourceSelectionMode.FROM_ORDER:
+            referenced_chunks = _from_order_source_selection_mode(
+                response_references, selected_chunks
+            )
+        case _:
+            raise ValueError(f"Invalid source selection mode: {source_selection_mode}")
+
+    return [chunk.text for chunk in referenced_chunks]
+
+
+def _default_source_selection_mode(
+    references: list[ContentReference], selected_chunks: list[ContentChunk]
+):
+    reference_ids = {reference.source_id for reference in references}
+
+    def build_chunk_id(chunk: ContentChunk) -> str:
+        return f"{chunk.id}_{chunk.chunk_id}"
+
+    referenced_chunks = [
+        chunk for chunk in selected_chunks if build_chunk_id(chunk) in reference_ids
+    ]
+
+    return referenced_chunks
+
+
+def _from_order_source_selection_mode(
+    references: list[ContentReference], selected_chunks: list[ContentChunk]
+):
+    original_chunks_order: list[int] = []
+    for reference in references:
+        for original_index in reference.original_index:
+            if original_index not in original_chunks_order:
+                original_chunks_order.append(original_index)
+
+    referenced_chunks: list[ContentChunk] = []
+    for index in original_chunks_order:
+        referenced_chunks.append(selected_chunks[index])
+
+    return referenced_chunks

unique_toolkit/agentic_table/__init__.py

@@ -0,0 +1,56 @@
+from unique_sdk.api_resources._agentic_table import (
+    ActivityStatus,
+    CellRendererTypes,
+    FilterTypes,
+    RowVerificationStatus,
+)
+
+from .schemas import (
+    AgenticTableSheetState,
+    AgreementStatus,
+    ArtifactType,
+    LogEntry,
+    MagicTableAction,
+    MagicTableAddMetadataPayload,
+    MagicTableBasePayload,
+    MagicTableCell,
+    MagicTableCellMetaData,
+    MagicTableEvent,
+    MagicTableEventTypes,
+    MagicTableGenerateArtifactPayload,
+    MagicTableLibrarySheetRowVerifiedPayload,
+    MagicTableSheet,
+    MagicTableSheetCompletedPayload,
+    MagicTableSheetCreatedPayload,
+    MagicTableUpdateCellPayload,
+    RowMetadataEntry,
+    SelectionMethod,
+)
+from .service import AgenticTableService
+
+__all__ = [
+    "AgenticTableService",
+    "ActivityStatus",
+    "AgenticTableSheetState",
+    "AgreementStatus",
+    "ArtifactType",
+    "CellRendererTypes",
+    "FilterTypes",
+    "LogEntry",
+    "MagicTableAction",
+    "MagicTableAddMetadataPayload",
+    "MagicTableBasePayload",
+    "MagicTableCell",
+    "MagicTableCellMetaData",
+    "MagicTableEvent",
+    "MagicTableEventTypes",
+    "MagicTableGenerateArtifactPayload",
+    "MagicTableLibrarySheetRowVerifiedPayload",
+    "MagicTableSheet",
+    "MagicTableSheetCompletedPayload",
+    "MagicTableSheetCreatedPayload",
+    "MagicTableUpdateCellPayload",
+    "RowMetadataEntry",
+    "RowVerificationStatus",
+    "SelectionMethod",
+]

unique_toolkit/agentic_table/schemas.py

@@ -0,0 +1,305 @@
+from enum import StrEnum
+from typing import Annotated, Any, Generic, Literal, TypeVar
+
+from pydantic import (
+    BaseModel,
+    Field,
+    field_validator,
+)
+from unique_sdk import (
+    AgenticTableSheetState,
+    AgreementStatus,
+    SelectionMethod,
+)
+from unique_sdk import LogDetail as SDKLogDetail
+from unique_sdk import LogEntry as SDKLogEntry
+from unique_sdk.api_resources._agentic_table import (
+    MagicTableAction,
+    SheetType,
+)
+
+from unique_toolkit._common.pydantic_helpers import get_configuration_dict
+from unique_toolkit.app.schemas import (
+    ChatEvent,
+    ChatEventAssistantMessage,
+    ChatEventUserMessage,
+)
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessageRole,
+    LanguageModelMessages,
+)
+
+
+class MagicTableEventTypes(StrEnum):
+    IMPORT_COLUMNS = "unique.magic-table.import-columns"
+    UPDATE_CELL = "unique.magic-table.update-cell"
+    ADD_DATA = "unique.magic-table.add-document"
+    ADD_META_DATA = "unique.magic-table.add-meta-data"
+    GENERATE_ARTIFACT = "unique.magic-table.generate-artifact"
+    SHEET_COMPLETED = "unique.magic-table.sheet-completed"
+    LIBRARY_SHEET_ROW_VERIFIED = "unique.magic-table.library-sheet-row.verified"
+    SHEET_CREATED = "unique.magic-table.sheet-created"
+
+
+class BaseMetadata(BaseModel):
+    model_config = get_configuration_dict()
+
+    sheet_type: SheetType = Field(
+        description="The type of the sheet.",
+        default=SheetType.DEFAULT,
+    )
+
+
+class RowMetadataEntry(BaseModel):
+    model_config = get_configuration_dict()
+    id: str = Field(description="The ID of the metadata")
+    key: str = Field(description="The key of the metadata")
+    value: str = Field(description="The value of the metadata")
+    exact_filter: bool = Field(
+        default=False,
+        description="Whether the metadata is to be used for strict filtering",
+    )
+
+
+class DDMetadata(BaseMetadata):
+    model_config = get_configuration_dict()
+
+    question_file_ids: list[str] = Field(
+        default_factory=list, description="The IDs of the question files"
+    )
+    source_file_ids: list[str] = Field(
+        default_factory=list, description="The IDs of the source files"
+    )
+    question_texts: list[str] = Field(
+        default_factory=list, description="The texts of the questions"
+    )
+    context: str = Field(default="", description="The context text for the table.")
+
+    @field_validator("context", mode="before")
+    @classmethod
+    def normalize_context(cls, v):
+        if v is None:
+            return ""
+        return v
+
+
+# Define template types
+A = TypeVar("A", bound=MagicTableAction)
+T = TypeVar("T", bound=BaseMetadata)
+
+
+class MagicTableBasePayload(BaseModel, Generic[A, T]):
+    model_config = get_configuration_dict()
+    name: str = Field(description="The name of the module")
+    sheet_name: str
+
+    action: A
+    chat_id: str
+    assistant_id: str
+    table_id: str
+    user_message: ChatEventUserMessage = Field(
+        default=ChatEventUserMessage(
+            id="", text="", original_text="", created_at="", language=""
+        )
+    )
+    assistant_message: ChatEventAssistantMessage = Field(
+        default=ChatEventAssistantMessage(id="", created_at="")
+    )
+    configuration: dict[str, Any] = {}
+    metadata: T
+    metadata_filter: dict[str, Any] | None = None
+
+
+########### Specialized Payload definitions ###########
+
+
+class MagicTableAddMetadataPayload(
+    MagicTableBasePayload[Literal[MagicTableAction.ADD_META_DATA], DDMetadata]
+): ...
+
+
+class MagicTableUpdateCellPayload(
+    MagicTableBasePayload[Literal[MagicTableAction.UPDATE_CELL], DDMetadata]
+):
+    column_order: int
+    row_order: int
+    data: str
+
+
+class ArtifactType(StrEnum):
+    QUESTIONS = "QUESTIONS"
+    FULL_REPORT = "FULL_REPORT"
+
+
+class ArtifactData(BaseModel):
+    model_config = get_configuration_dict()
+    artifact_type: ArtifactType
+
+
+class MagicTableGenerateArtifactPayload(
+    MagicTableBasePayload[Literal[MagicTableAction.GENERATE_ARTIFACT], BaseMetadata]
+):
+    data: ArtifactData
+
+
+########## Sheet Completed Payload ##########
+
+
+class SheetCompletedMetadata(BaseMetadata):
+    model_config = get_configuration_dict()
+    sheet_id: str = Field(description="The ID of the sheet that was completed.")
+    library_sheet_id: str = Field(
+        description="The ID of the library corresponding to the sheet."
+    )
+    context: str = Field(default="", description="The context text for the table.")
+
+    @field_validator("context", mode="before")
+    @classmethod
+    def normalize_context(cls, v):
+        if v is None:
+            return ""
+        return v
+
+
+class MagicTableSheetCompletedPayload(
+    MagicTableBasePayload[
+        Literal[MagicTableAction.SHEET_COMPLETED], SheetCompletedMetadata
+    ]
+): ...
+
+
+class SheetCreatedMetadata(BaseMetadata): ...
+
+
+class MagicTableSheetCreatedPayload(
+    MagicTableBasePayload[Literal[MagicTableAction.SHEET_CREATED], SheetCreatedMetadata]
+): ...
+
+
+########## Library Sheet Row Verified Payload ##########
+
+
+class LibrarySheetRowVerifiedMetadata(BaseMetadata):
+    model_config = get_configuration_dict()
+    row_order: int = Field(description="The row index of the row that was verified.")
+
+
+class MagicTableLibrarySheetRowVerifiedPayload(
+    MagicTableBasePayload[
+        Literal[MagicTableAction.LIBRARY_SHEET_ROW_VERIFIED],
+        LibrarySheetRowVerifiedMetadata,
+    ]
+): ...
+
+
+########### Magic Table Event definition ###########
+
+
+PayloadTypes = (
+    MagicTableUpdateCellPayload
+    | MagicTableAddMetadataPayload
+    | MagicTableGenerateArtifactPayload
+    | MagicTableSheetCompletedPayload
+    | MagicTableLibrarySheetRowVerifiedPayload
+    | MagicTableSheetCreatedPayload
+)
+
+MagicTablePayloadTypes = Annotated[PayloadTypes, Field(discriminator="action")]
+
+
+class MagicTableEvent(ChatEvent):
+    event: MagicTableEventTypes  # type: ignore[assignment]
+    payload: MagicTablePayloadTypes  # type: ignore[assignment]
+
+
+class LogDetail(BaseModel):
+    model_config = get_configuration_dict()
+    llm_request: LanguageModelMessages | None = Field(
+        default=None, description="The LLM request for the log detail"
+    )
+
+    def to_sdk_log_detail(self) -> SDKLogDetail:
+        llm_request = None
+        if self.llm_request:
+            llm_request = self.llm_request.model_dump()
+        return SDKLogDetail(llmRequest=llm_request)
+
+
+class LogEntry(BaseModel):
+    model_config = get_configuration_dict()
+
+    text: str
+    created_at: str
+    actor_type: LanguageModelMessageRole
+    message_id: str | None = None
+    details: LogDetail | None = Field(
+        default=None, description="The details of the log entry"
+    )
+
+    @field_validator("actor_type", mode="before")
+    @classmethod
+    def normalize_actor_type(cls, v):
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
+    def to_sdk_log_entry(self) -> SDKLogEntry:
+        params: dict[str, Any] = {
+            "text": self.text,
+            "createdAt": self.created_at,
+            "actorType": self.actor_type.value.upper(),
+        }
+        if self.details:
+            params["details"] = self.details.to_sdk_log_detail()
+
+        return SDKLogEntry(**params)
+
+
+class MagicTableCellMetaData(BaseModel):
+    model_config = get_configuration_dict()
+    row_order: int = Field(description="The row index of the cell.")
+    column_order: int = Field(description="The column index of the cell.")
+    selected: bool | None = None
+    selection_method: SelectionMethod | None = None
+    agreement_status: AgreementStatus | None = None
+
+
+class MagicTableCell(BaseModel):
+    model_config = get_configuration_dict()
+    sheet_id: str
+    row_order: int = Field(description="The row index of the cell.")
+    column_order: int = Field(description="The column index of the cell.")
+    row_locked: bool = Field(default=False, description="Lock status of the row.")
+    text: str
+    log_entries: list[LogEntry] = Field(
+        default_factory=list, description="The log entries for the cell"
+    )
+    meta_data: MagicTableCellMetaData | None = Field(
+        default=None, description="The metadata for the cell"
+    )
+    row_metadata: list[RowMetadataEntry] = Field(
+        default_factory=list,
+        description="The metadata (key value pairs)for the rows.",
+    )
+
+
+class MagicTableSheet(BaseModel):
+    model_config = get_configuration_dict()
+    sheet_id: str
+    name: str
+    state: AgenticTableSheetState
+    total_number_of_rows: int = Field(
+        default=0,
+        description="The total number of rows in the sheet",
+        alias="magicTableRowCount",
+    )
+    chat_id: str
+    created_by: str
+    company_id: str
+    created_at: str
+    magic_table_cells: list[MagicTableCell] = Field(
+        default_factory=list, description="The cells in the sheet"
+    )
+    magic_table_sheet_metadata: list[RowMetadataEntry] = Field(
+        default_factory=list, description="The metadata for the sheet"
+    )

unique_toolkit/agentic_table/service.py

@@ -0,0 +1,452 @@
+import logging
+
+from typing_extensions import deprecated
+from unique_sdk import (
+    AgenticTable,
+    AgenticTableSheetState,
+    AgreementStatus,
+    CellRendererTypes,
+    FilterTypes,
+    RowVerificationStatus,
+    SelectionMethod,
+)
+from unique_sdk import AgenticTableCell as SDKAgenticTableCell
+from unique_sdk.api_resources._agentic_table import ActivityStatus
+
+from .schemas import (
+    ArtifactType,
+    LogEntry,
+    MagicTableAction,
+    MagicTableCell,
+    MagicTableSheet,
+    RowMetadataEntry,
+)
+
+
+class LockedAgenticTableError(Exception):
+    pass
+
+
+class AgenticTableService:
+    """
+    Provides methods to interact with the Agentic Table.
+
+    Attributes:
+        #event (ChatEvent): The ChatEvent object.
+        logger (Optional[logging.Logger]): The logger object. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        user_id: str,
+        company_id: str,
+        table_id: str,
+        event_id: str | None = None,
+        logger: logging.Logger = logging.getLogger(__name__),
+    ):
+        self._event_id = event_id
+        self._user_id = user_id
+        self._company_id = company_id
+        self.table_id = table_id
+        self.logger = logger
+
+    async def set_cell(
+        self,
+        row: int,
+        column: int,
+        text: str,
+        log_entries: list[LogEntry] | None = None,
+    ):
+        """
+        Sets the value of a cell in the Agentic Table.
+
+        Args:
+            row (int): The row index.
+            column (int): The column index.
+            text (str): The text to set.
+            log_entries (Optional[list[LogEntry]]): The log entries to set.
+        """
+        if log_entries is None:
+            log_entries_new = []
+        else:
+            log_entries_new = [
+                log_entry.to_sdk_log_entry() for log_entry in log_entries
+            ]
+        try:
+            await AgenticTable.set_cell(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                tableId=self.table_id,
+                rowOrder=row,
+                columnOrder=column,
+                text=text,
+                logEntries=log_entries_new,
+            )
+        except Exception as e:
+            self.logger.error(f"Error setting cell {row}, {column}: {e}.")
+
+    async def get_cell(
+        self, row: int, column: int, include_row_metadata: bool = True
+    ) -> MagicTableCell:
+        """
+        Gets the value of a cell in the Agentic Table.
+
+        Args:
+            row (int): The row index.
+            column (int): The column index.
+            include_row_metadata (bool): Whether to include the row metadata. Defaults to True.
+
+        Returns:
+            MagicTableCell: The MagicTableCell object.
+
+        """
+        cell_data = await AgenticTable.get_cell(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            rowOrder=row,
+            columnOrder=column,
+            includeRowMetadata=include_row_metadata,  # type: ignore[arg-type]
+        )
+        return MagicTableCell.model_validate(cell_data)
+
+    async def set_multiple_cells(
+        self, cells: list[MagicTableCell], batch_size: int = 4000
+    ):
+        """
+        Sets the values of multiple cells in the Agentic Table.
+
+        Args:
+            cells (list[MagicTableCell]): The cells to set sorted by row and column.
+            batch_size (int): Number of cells to set in a single request.
+        """
+        for i in range(0, len(cells), batch_size):
+            batch = cells[i : i + batch_size]
+            await AgenticTable.set_multiple_cells(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                tableId=self.table_id,
+                cells=[
+                    SDKAgenticTableCell(
+                        rowOrder=cell.row_order,
+                        columnOrder=cell.column_order,
+                        text=cell.text,
+                    )
+                    for cell in batch
+                ],
+            )
+
+    async def set_activity(
+        self,
+        text: str,
+        activity: MagicTableAction,
+        status: ActivityStatus = ActivityStatus.IN_PROGRESS,
+    ):
+        """
+        Sets the activity of the Agentic Table.
+
+        Args:
+            activity (str): The activity to set.
+        """
+        await AgenticTable.set_activity(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            activity=activity.value,  # type: ignore[arg-type]
+            status=status.value,  # type: ignore[arg-type]
+            text=text,
+        )
+
+    async def register_agent(self) -> None:
+        """
+        Registers the agent for the Agentic Table by updating the sheet state to PROCESSING.
+
+        Raises:
+            LockedAgenticTableError: If the Agentic Table is busy.
+        """
+        state = await AgenticTable.get_sheet_state(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+        )
+        if state == AgenticTableSheetState.IDLE:
+            await AgenticTable.update_sheet_state(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                tableId=self.table_id,
+                state=AgenticTableSheetState.PROCESSING,
+            )
+            return
+        # If the sheet is not idle, we cannot register the agent
+        raise LockedAgenticTableError(
+            f"Agentic Table is busy. Cannot register agent {self._event_id or self.table_id}."
+        )
+
+    async def deregister_agent(self):
+        """
+        Deregisters the agent for the Agentic Table by updating the sheet state to IDLE.
+
+        Raises:
+            LockedAgenticTableError: If the Agentic Table is busy.
+        """
+        await AgenticTable.update_sheet_state(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            state=AgenticTableSheetState.IDLE,
+        )
+
+    async def set_artifact(
+        self,
+        artifact_type: ArtifactType,
+        content_id: str,
+        mime_type: str,
+        name: str,
+    ):
+        """Upload/set report files to the Agentic Table.
+
+        Args:
+            artifact_type (ArtifactType): The type of artifact to set.
+            content_id (str): The content ID of the artifact.
+            mime_type (str): The MIME type of the artifact.
+            name (str): The name of the artifact.
+        """
+        await AgenticTable.set_artifact(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            artifactType=artifact_type.value,
+            contentId=content_id,
+            mimeType=mime_type,
+            name=name,
+        )
+
+    @deprecated("Use set_column_style instead.")
+    async def set_column_width(self, column: int, width: int):
+        await self.set_column_style(column=column, width=width)
+
+    async def set_column_style(
+        self,
+        column: int,
+        width: int | None = None,
+        cell_renderer: CellRendererTypes | None = None,
+        filter: FilterTypes | None = None,
+        editable: bool | None = None,
+    ):
+        """
+        Sets the style of a column in the Agentic Table.
+
+        Args:
+            column (int): The column index.
+            width (int | None, optional): The width of the column. Defaults to None.
+            cell_renderer (CellRenderer | None, optional): The cell renderer of the column. Defaults to None.
+            filter (FilterComponents | None, optional): The filter of the column. Defaults to None.
+            editable (bool | None, optional): Whether the column is editable. Defaults to None.
+
+        Raises:
+            Exception: If the column style is not set.
+        """
+        # Convert the input to the correct format
+        params = {}
+        if width is not None:
+            params["columnWidth"] = width
+        if cell_renderer is not None:
+            params["cellRenderer"] = cell_renderer.value
+        if filter is not None:
+            params["filter"] = filter.value
+        if editable is not None:
+            params["editable"] = editable
+        status, message = await AgenticTable.set_column_metadata(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            columnOrder=column,
+            **params,
+        )
+        if status:
+            return
+        raise Exception(message)
+
+    async def get_num_rows(self) -> int:
+        """
+        Gets the number of rows in the Agentic Table.
+
+        Returns:
+            int: The number of rows in the Agentic Table.
+        """
+        sheet_info = await AgenticTable.get_sheet_data(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            includeRowCount=True,
+            includeCells=False,
+            includeLogHistory=False,
+        )
+        return sheet_info["magicTableRowCount"]
+
+    async def get_sheet(
+        self,
+        start_row: int = 0,
+        end_row: int | None = None,
+        batch_size: int = 100,
+        include_log_history: bool = False,
+        include_cell_meta_data: bool = False,
+        include_row_metadata: bool = False,
+    ) -> MagicTableSheet:
+        """
+        Gets the sheet data from the Agentic Table paginated by batch_size.
+
+        Args:
+            start_row (int): The start row (inclusive).
+            end_row (int | None): The end row (not inclusive).
+            batch_size (int): The batch size.
+            include_log_history (bool): Whether to include the log history.
+            include_cell_meta_data (bool): Whether to include the cell metadata (renderer, selection, agreement status).
+            include_row_metadata (bool): Whether to include the row metadata (key value pairs).
+        Returns:
+            MagicTableSheet: The sheet data.
+        """
+        # Find the total number of rows
+        sheet_info = await AgenticTable.get_sheet_data(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            includeRowCount=True,
+            includeCells=False,
+            includeLogHistory=False,
+            includeCellMetaData=False,
+        )
+        total_rows = sheet_info["magicTableRowCount"]
+        if end_row is None or end_row > total_rows:
+            end_row = total_rows
+        if start_row > end_row:
+            raise Exception("Start row is greater than end row")
+        if start_row < 0 or end_row < 0:
+            raise Exception("Start row or end row is negative")
+
+        # Get the cells
+        cells = []
+        for row in range(start_row, end_row, batch_size):
+            end_row_batch = min(row + batch_size, end_row)
+            sheet_partial = await AgenticTable.get_sheet_data(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                tableId=self.table_id,
+                includeCells=True,
+                includeLogHistory=include_log_history,
+                includeRowCount=False,
+                includeCellMetaData=include_cell_meta_data,  # renderer, selection, agreement status
+                startRow=row,
+                endRow=end_row_batch - 1,
+            )
+            if "magicTableCells" in sheet_partial:
+                if include_row_metadata:
+                    # If include_row_metadata is true, we need to get the row metadata for each cell.
+                    row_metadata_map = {}
+                    # TODO: @thea-unique This routine is not efficient and would be nice if we had this data passed on in get_sheet_data.
+                    for cell in sheet_partial["magicTableCells"]:
+                        row_order = cell.get("rowOrder")  # type: ignore[assignment]
+                        if row_order is not None and row_order not in row_metadata_map:
+                            column_order = cell.get("columnOrder")  # type: ignore[assignment]
+                            self.logger.info(
+                                f"Getting row metadata for cell {row_order}, {column_order}"
+                            )
+                            cell_with_row_metadata = await self.get_cell(
+                                row_order,
+                                column_order,  # type: ignore[arg-type]
+                            )
+                            if cell_with_row_metadata.row_metadata:
+                                print(cell_with_row_metadata.row_metadata)
+                                row_metadata_map[cell_with_row_metadata.row_order] = (
+                                    cell_with_row_metadata.row_metadata
+                                )
+                                cell["rowMetadata"] = (  # type: ignore[assignment]
+                                    cell_with_row_metadata.row_metadata
+                                )
+                    # Assign row_metadata to all cells
+                    for cell in sheet_partial["magicTableCells"]:
+                        row_order = cell.get("rowOrder")  # type: ignore[assignment]
+                        if row_order is not None and row_order in row_metadata_map:
+                            cell["rowMetadata"] = row_metadata_map[  # type: ignore[assignment]
+                                row_order
+                            ]
+
+                cells.extend(sheet_partial["magicTableCells"])
+
+        sheet_info["magicTableCells"] = cells
+        return MagicTableSheet.model_validate(sheet_info)
+
+    async def get_sheet_metadata(self) -> list[RowMetadataEntry]:
+        """
+        Gets the sheet metadata from the Agentic Table.
+
+        Returns:
+            list[RowMetadataEntry]: The sheet metadata.
+        """
+        sheet_info = await AgenticTable.get_sheet_data(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            includeSheetMetadata=True,  # type: ignore[arg-type]
+        )
+        return [
+            RowMetadataEntry.model_validate(metadata)
+            for metadata in sheet_info["magicTableSheetMetadata"]
+        ]
+
+    async def set_cell_metadata(
+        self,
+        row: int,
+        column: int,
+        selected: bool | None = None,
+        selection_method: SelectionMethod | None = None,
+        agreement_status: AgreementStatus | None = None,
+    ) -> None:
+        """
+        Sets the cell metadata for the Agentic Table.
+        NOTE: This is not to be confused with the sheet metadata and is associated rather with selection and agreement status, row locking etc.
+
+        Args:
+            row (int): The row index.
+            column (int): The column index.
+            selected (bool | None): Whether the cell is selected.
+            selection_method (SelectionMethod | None): The method of selection.
+            agreement_status (AgreementStatus | None): The agreement status.
+        """
+        params = {}
+        if selected is not None:
+            params["selected"] = selected
+        if selection_method is not None:
+            params["selectionMethod"] = selection_method
+        if agreement_status is not None:
+            params["agreementStatus"] = agreement_status
+        result = await AgenticTable.set_cell_metadata(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            rowOrder=row,
+            columnOrder=column,
+            **params,
+        )
+        if result["status"]:  # type: ignore
+            return
+        raise Exception(result["message"])  # type: ignore
+
+    async def update_row_verification_status(
+        self,
+        row_orders: list[int],
+        status: RowVerificationStatus,
+    ):
+        """Update the verification status of multiple rows at once.
+
+        Args:
+            row_orders (list[int]): The row indexes to update.
+            status (RowVerificationStatus): The verification status to set.
+        """
+        await AgenticTable.bulk_update_status(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            rowOrders=row_orders,
+            status=status,
+        )

unique_toolkit/app/fast_api_factory.py

@@ -1,6 +1,6 @@
 import json
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar
 
 from pydantic import ValidationError
 
@@ -35,13 +35,15 @@ def default_event_handler(event: Any) -> int:
 
 T = TypeVar("T", bound=BaseEvent)
 
+EventHandlerType = Callable[[T], Awaitable[int]] | Callable[[T], int]
+
 
 def build_unique_custom_app(
     *,
     title: str = "Unique Chat App",
     webhook_path: str = "/webhook",
     settings: UniqueSettings,
-    event_handler: Callable[[T], int] = default_event_handler,
+    event_handler: EventHandlerType = default_event_handler,
     event_constructor: Callable[..., T] = ChatEvent,
     subscribed_event_names: list[str] | None = None,
 ) -> "FastAPI":
@@ -106,11 +108,17 @@ def build_unique_custom_app(
 
         try:
             event = event_constructor(**event_data)
-            if event.filter_event(filter_options=settings.chat_event_filter_options):
-                return JSONResponse(
-                    status_code=status.HTTP_200_OK,
-                    content={"error": "Event filtered out"},
-                )
+            if (
+                settings.chat_event_filter_options
+                and settings.chat_event_filter_options.assistant_ids
+            ):
+                if event.filter_event(
+                    filter_options=settings.chat_event_filter_options
+                ):
+                    return JSONResponse(
+                        status_code=status.HTTP_200_OK,
+                        content={"error": "Event filtered out"},
+                    )
         except ValidationError as e:
             # pydantic errors https://docs.pydantic.dev/2.10/errors/errors/
             logger.error(f"Validation error with model: {e.json()}", exc_info=True)

{unique_toolkit-1.40.0.dist-info → unique_toolkit-1.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.40.0
+Version: 1.41.0
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -123,6 +123,13 @@ 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.41.0] - 2025-12-29
+- Add `AgenticTable` service to unique_toolkit
+
+## [1.40.0] - 2025-12-22
+- Add option to use retrieve referenced chunks from their order
+
 ## [1.40.0] - 2025-12-22
 - Add `hide_in_chat` parameter to `upload_to_chat_from_bytes` and `upload_to_chat_from_bytes_async`
 - Hide code interpreter files in chat 

{unique_toolkit-1.40.0.dist-info → unique_toolkit-1.41.0.dist-info}/RECORD

@@ -54,7 +54,7 @@ unique_toolkit/agentic/evaluation/hallucination/constants.py,sha256=SoGmoYti2J33
 unique_toolkit/agentic/evaluation/hallucination/hallucination_evaluation.py,sha256=x5ta2Fum4fE5ySgIXPKlnbTtmV140z0IazSATd0-REg,4092
 unique_toolkit/agentic/evaluation/hallucination/prompts.py,sha256=O3Hi_rOzZlujvnO2wn2jhoPmrYLjzVtRWwxn5Q81m9Y,3405
 unique_toolkit/agentic/evaluation/hallucination/service.py,sha256=WJF1f45uHnYLx1S4TW31bSFobFpV-YlOS3G_zMhuBVU,2512
-unique_toolkit/agentic/evaluation/hallucination/utils.py,sha256=kM5kqUZb5riINr1Oqf3wyrj25o25H2WaJ64haKTJLMo,8213
+unique_toolkit/agentic/evaluation/hallucination/utils.py,sha256=uHKTJw4kJyq0_Gi-EOhbocBAij4_Vzn3dW1wTxAuFg4,9706
 unique_toolkit/agentic/evaluation/output_parser.py,sha256=0FDo8YY_Dc4qlTNeYyQkznzIFj9aX9wMrLOTbhhTl6g,1418
 unique_toolkit/agentic/evaluation/schemas.py,sha256=m9JMCUmeqP8KhsJOVEzsz6dRXUe1uKw-bxRDtn5qwvM,3156
 unique_toolkit/agentic/evaluation/tests/test_context_relevancy_service.py,sha256=4tDxHTApbaTMxN1sNS8WCqj2BweRk6YqZ5_zHP45jto,7977
@@ -137,9 +137,12 @@ unique_toolkit/agentic/tools/utils/source_handling/__init__.py,sha256=47DEQpj8HB
 unique_toolkit/agentic/tools/utils/source_handling/schema.py,sha256=iHBKuks6tUy8tvian4Pd0B6_-8__SehVVNcxIUAUjEA,882
 unique_toolkit/agentic/tools/utils/source_handling/source_formatting.py,sha256=uZ0QXqrPWgId3ZA67dvjHQ6xrW491LK1xxx_sVJmFHg,9160
 unique_toolkit/agentic/tools/utils/source_handling/tests/test_source_formatting.py,sha256=EA8iVvb3L91OFk2XMbGcFuhe2etqm3Sx9QCYDGiOSOM,6995
+unique_toolkit/agentic_table/__init__.py,sha256=smJFstF5qH35RmZfzJUigdsVgUVNOza9KxMbraWrm9E,1411
+unique_toolkit/agentic_table/schemas.py,sha256=VOEp3yjpgE3j1plPAlWNoQ16tDB3pBvu6HsS9WSqdu0,8907
+unique_toolkit/agentic_table/service.py,sha256=Bgi0B_AT7Mswbud3VI-pNcnc_85xFu4S1dbLttYF7yY,16290
 unique_toolkit/app/__init__.py,sha256=OaylhLwxeRlsHlcFGSlR5R7oREFsjv9wRdxuVZBYM_8,1371
 unique_toolkit/app/dev_util.py,sha256=J20peCvrSQKfMGdYPYwCirs3Yq2v_e33GzNBzNKbWN4,5531
-unique_toolkit/app/fast_api_factory.py,sha256=i65-zjTg2D4GOKIbaSkHBTxgjAP-rmFDeJpVYKxziXk,4633
+unique_toolkit/app/fast_api_factory.py,sha256=4xoN23abH4LnRsM9atu97WEHK3-nH29LiWsI50whH_U,4923
 unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3h23gQ,678
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
@@ -212,7 +215,7 @@ unique_toolkit/short_term_memory/service.py,sha256=5PeVBu1ZCAfyDb2HLVvlmqSbyzBBu
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/smart_rules/compile.py,sha256=Ozhh70qCn2yOzRWr9d8WmJeTo7AQurwd3tStgBMPFLA,1246
 unique_toolkit/test_utilities/events.py,sha256=_mwV2bs5iLjxS1ynDCjaIq-gjjKhXYCK-iy3dRfvO3g,6410
-unique_toolkit-1.40.0.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.40.0.dist-info/METADATA,sha256=iEwBy-tYmByLek8I9T4Eck-LCO5eDQKtk8fkAgnhS-g,46331
-unique_toolkit-1.40.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.40.0.dist-info/RECORD,,
+unique_toolkit-1.41.0.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-1.41.0.dist-info/METADATA,sha256=nfWPkb3z7-IQBPeeLrcFN8AJm2MmuwPGlA9t-5XgStY,46495
+unique_toolkit-1.41.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-1.41.0.dist-info/RECORD,,