abacusai 1.3.4__tar.gz → 1.3.5__tar.gz

{abacusai-1.3.4/abacusai.egg-info → abacusai-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abacusai
-Version: 1.3.4
+Version: 1.3.5
 Summary: Abacus.AI Python Client Library
 Home-page: https://github.com/abacusai/api-python
 Author: Abacus.AI

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/__init__.py

@@ -4,4 +4,4 @@ from .prediction_client import PredictionClient
 from .streaming_client import StreamingClient
 
 
-__version__ = "1.3.4"
+__version__ = "1.3.5"

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_class/__init__.py

@@ -15,3 +15,4 @@ from .monitor_alert import *
 from .project import *
 from .python_functions import *
 from .refresh import *
+from .segments import *

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_class/ai_agents.py

@@ -100,7 +100,7 @@ class WorkflowNodeInputMapping(ApiClass):
     @classmethod
     def from_dict(cls, mapping: dict):
         if any(field not in mapping for field in ['name', 'variable_type']):
-            raise ValueError('Invalid workflow node input mapping. Must contain keys - name, variable_type')
+            raise ValueError('input_mapping', f'Invalid workflow node input mapping "{mapping}". Must contain keys - name, variable_type')
         return cls(
             name=mapping['name'],
             variable_type=mapping['variable_type'],
@@ -158,7 +158,7 @@ class WorkflowGraphNode(ApiClass):
             self.function_name = function_name
             self.source_code = source_code
         else:
-            raise ValueError('Either function or function_name and source_code must be provided.')
+            raise ValueError('workflow_graph_node', 'Either function or function_name and source_code must be provided.')
 
         self.name = name
         self.input_mappings = input_mappings
@@ -182,7 +182,7 @@ class WorkflowGraphNode(ApiClass):
     @classmethod
     def from_dict(cls, node: dict):
         if any(field not in node for field in ['name', 'function_name', 'source_code', 'input_mappings', 'output_mappings']):
-            raise ValueError('Invalid workflow graph node. Must contain keys - name, function_name, source_code, input_mappings, output_mappings.')
+            raise ValueError('workflow_graph_node', 'Invalid workflow graph node. Must contain keys - name, function_name, source_code, input_mappings, output_mappings.')
         return cls(
             name=node['name'],
             function_name=node['function_name'],
@@ -223,19 +223,23 @@ class WorkflowGraph(ApiClass):
     Args:
         nodes (List[WorkflowGraphNode]): A list of nodes in the workflow graph.
         edges (List[WorkflowGraphEdge]): A list of edges in the workflow graph, where each edge is a tuple of source, target and details.
+        primary_start_node (str): The primary node to start the workflow from.
     """
     nodes: List[WorkflowGraphNode] = dataclasses.field(default_factory=list)
     edges: List[WorkflowGraphEdge] = dataclasses.field(default_factory=list)
+    primary_start_node: str = dataclasses.field(default=None)
 
     def to_dict(self):
         return {
             'nodes': [node.to_dict() for node in self.nodes],
-            'edges': [edge.to_dict() for edge in self.edges]
+            'edges': [edge.to_dict() for edge in self.edges],
+            'primary_start_node': self.primary_start_node
         }
 
     @classmethod
     def from_dict(cls, graph: dict):
         return cls(
             nodes=[WorkflowGraphNode.from_dict(node) for node in graph.get('nodes', [])],
-            edges=[WorkflowGraphEdge.from_dict(edge) for edge in graph.get('edges', [])]
+            edges=[WorkflowGraphEdge.from_dict(edge) for edge in graph.get('edges', [])],
+            primary_start_node=graph.get('primary_start_node', None)
         )

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_class/dataset.py

@@ -42,7 +42,6 @@ class DocumentProcessingConfig(ApiClass):
         remove_header_footer (bool): Whether to remove headers and footers. Defaults to False. This option only takes effect when extract_bounding_boxes is True.
         remove_watermarks (bool): Whether to remove watermarks. By default, it will be decided automatically based on the OCR mode and the document type. This option only takes effect when extract_bounding_boxes is True.
         convert_to_markdown (bool): Whether to convert extracted text to markdown. Defaults to False. This option only takes effect when extract_bounding_boxes is True.
-        return_links (bool): Whether to augment the extracted text with embedded URLs in the PDF. Defaults to False. This option only takes effect when the document is a PDF.
     """
     # NOTE: The defaults should match with clouddb.document_processing_results table defaults
     extract_bounding_boxes: bool = False
@@ -51,7 +50,6 @@ class DocumentProcessingConfig(ApiClass):
     remove_header_footer: bool = False
     remove_watermarks: bool = True
     convert_to_markdown: bool = False
-    return_links: bool = False
 
 
 @dataclasses.dataclass

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_class/enums.py

@@ -586,3 +586,15 @@ class MemorySize(ApiEnum):
             if member.value >= value:
                 return member
         return None
+
+
+class SegmentType(ApiEnum):
+    ATTACHMENTS = 'attachments'
+    AGENT_FLOW_BUTTON = 'agent_flow_button'
+    IMAGE_URL = 'image_url'
+    TEXT = 'text'
+
+
+class CodeSegmentLanguage(ApiEnum):
+    PYTHON = 'python'
+    SQL = 'sql'

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_class/model.py

@@ -65,6 +65,7 @@ class PersonalizationTrainingConfig(TrainingConfig):
         min_item_history (int): Minimum number of interactions an item must have to be included in training.
         query_column (str): Name of column in the interactions table that represents a natural language query, e.g. 'blue t-shirt'.
         item_query_column (str): Name of column in the item catalog that will be matched to the query column in the interactions table.
+        include_item_id_feature (bool): Add Item-Id to the input features of the model. Applicable for Embedding distance and CTR models.
     """
     # top-level params
     objective: enums.PersonalizationObjective = dataclasses.field(default=None)
@@ -112,6 +113,7 @@ class PersonalizationTrainingConfig(TrainingConfig):
     item_query_column: str = dataclasses.field(default=None)
     use_user_id_feature: bool = dataclasses.field(default=None)
     session_dedupe_mins: float = dataclasses.field(default=None)
+    include_item_id_feature: bool = dataclasses.field(default=None)
 
     # outliers
     max_user_history_len_percentile: int = dataclasses.field(default=None)
@@ -171,7 +173,10 @@ class RegressionTrainingConfig(TrainingConfig):
         custom_metrics (List[str]): Registered custom metrics available for selection.
         partial_dependence_analysis (PartialDependenceAnalysis): Specify whether to run partial dependence plots for all features or only some features.
         do_masked_language_model_pretraining (bool): Specify whether to run a masked language model unsupervised pretraining step before supervized training in certain supported algorithms which use BERT-like backbones.
-    """
+        max_tokens_in_sentence (int): Specify the max tokens to be kept in a sentence based on the truncation strategy.
+        truncation_strategy (str): What strategy to use to deal with text rows with more than a given number of tokens (if num of tokens is more than "max_tokens_in_sentence").
+     """
+
     objective: enums.RegressionObjective = dataclasses.field(default=None)
     sort_objective: enums.RegressionObjective = dataclasses.field(default=None)
     tree_hpo_mode: enums.RegressionTreeHPOMode = dataclasses.field(default=None)
@@ -215,6 +220,8 @@ class RegressionTrainingConfig(TrainingConfig):
     pretrained_model_name: str = dataclasses.field(default=None)
     is_multilingual: bool = dataclasses.field(default=None)
     do_masked_language_model_pretraining: bool = dataclasses.field(default=None)
+    max_tokens_in_sentence: int = dataclasses.field(default=None)
+    truncation_strategy: str = dataclasses.field(default=None)
 
     # loss function
     loss_function: enums.RegressionLossFunction = dataclasses.field(default=None)
@@ -299,7 +306,7 @@ class ForecastingTrainingConfig(TrainingConfig):
         use_all_item_totals (bool): Include as input total target across items.
         handle_zeros_as_missing_values (bool): If True, handle zero values in demand as missing data.
         datetime_holiday_calendars (List[HolidayCalendars]): Holiday calendars to augment training with.
-        fill_missing_values (List[dict]): Strategy for filling in missing values.
+        fill_missing_values (List[List[dict]]): Strategy for filling in missing values.
         enable_clustering (bool): Enable clustering in forecasting.
         data_split_feature_group_table_name (str): Specify the table name of the feature group to export training data with the fold column.
         custom_loss_functions (List[str]): Registered custom losses available for selection.
@@ -368,7 +375,7 @@ class ForecastingTrainingConfig(TrainingConfig):
     use_all_item_totals: bool = dataclasses.field(default=None)
     handle_zeros_as_missing_values: bool = dataclasses.field(default=None)
     datetime_holiday_calendars: List[enums.HolidayCalendars] = dataclasses.field(default=None)
-    fill_missing_values: List[dict] = dataclasses.field(default=None)
+    fill_missing_values: List[List[dict]] = dataclasses.field(default=None)
     enable_clustering: bool = dataclasses.field(default=None)
     # Others
     data_split_feature_group_table_name: str = dataclasses.field(default=None)
@@ -656,7 +663,7 @@ class TimeseriesAnomalyTrainingConfig(TrainingConfig):
         type_of_split (TimeseriesAnomalyDataSplitType): Type of data splitting into train/test.
         test_start (str): Limit training data to dates before the given test start.
         test_split (int): Percent of dataset to use for test data. We support using a range between 5 ( i.e. 5% ) to 20 ( i.e. 20% ) of your dataset.
-        fill_missing_values (List[dict]): strategies to fill missing values and missing timestamps
+        fill_missing_values (List[List[dict]]): strategies to fill missing values and missing timestamps
         handle_zeros_as_missing_values (bool): If True, handle zero values in numeric columns as missing data
         timeseries_frequency (str): set this to control frequency of filling missing values
         min_samples_in_normal_region (int): Adjust this to fine-tune the number of anomalies to be identified.
@@ -667,7 +674,7 @@ class TimeseriesAnomalyTrainingConfig(TrainingConfig):
     type_of_split: enums.TimeseriesAnomalyDataSplitType = dataclasses.field(default=None)
     test_start: str = dataclasses.field(default=None)
     test_split: int = dataclasses.field(default=None)
-    fill_missing_values: List[dict] = dataclasses.field(default=None)
+    fill_missing_values: List[List[dict]] = dataclasses.field(default=None)
     handle_zeros_as_missing_values: bool = dataclasses.field(default=None)
     timeseries_frequency: str = dataclasses.field(default=None)
     min_samples_in_normal_region: int = dataclasses.field(default=None)

abacusai-1.3.5/abacusai/api_class/segments.py

@@ -0,0 +1,128 @@
+import dataclasses
+from typing import List
+
+from . import enums
+from .abstract import ApiClass
+
+
+@dataclasses.dataclass
+class Attachment(ApiClass):
+    """
+    An attachment that an agent can return to render attachments.
+
+    Args:
+        filename (str): The name of the file.
+        mime_type (str): The MIME type of the file.
+        attachment_id (str): The ID of the attachment.
+    """
+
+    filename: str
+    mime_type: str
+    attachment_id: str
+
+    def to_dict(self):
+        return {
+            'type': 'attachment',
+            'filename': self.filename,
+            'mime_type': self.mime_type,
+            'attachment_id': self.attachment_id
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(filename=data['filename'], mime_type=data['mime_type'], attachment_id=data['attachment_id'])
+
+
+@dataclasses.dataclass
+class Segment(ApiClass):
+    """
+    A segment that an agent can return to render specific UI elements.
+
+    Args:
+        type (SegmentType): The type of the segment.
+        id (str): The section key of the segment.
+    """
+
+    type: enums.SegmentType
+    id: str
+
+    def to_dict(self):
+        return {k: v.value if isinstance(v, enums.Enum) else v for k, v in dataclasses.asdict(self).items()}
+
+
+@dataclasses.dataclass
+class AttachmentsSegment(Segment):
+    """
+    A segment that an agent can return to render attachments.
+
+    Args:
+        attachments (List[Attachment]): The list of attachments to be displayed.
+    """
+
+    attachments: List[Attachment]
+
+    def __init__(self, attachments: List[Attachment], section_key: str = None):
+        super().__init__(type=enums.SegmentType.ATTACHMENTS, id=section_key)
+        self.attachments = attachments
+
+    def to_dict(self):
+        return {
+            'type': self.type.value,
+            'id': self.id,
+            'attachments': [attachment.to_dict() for attachment in self.attachments]
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(attachments=[Attachment.from_dict(attachment) for attachment in data['attachments']])
+
+
+@dataclasses.dataclass
+class AgentFlowButtonSegment(Segment):
+    """
+    A segment that an AI Agent can return to render a button.
+
+    Args:
+        label (str): The label of the button.
+        agent_workflow_node_name (str): The workflow start node to be executed when the button is clicked.
+    """
+
+    label: str
+    agent_workflow_node_name: str
+
+    def __init__(self, label: str, agent_workflow_node_name: str, section_key: str = None):
+        super().__init__(type=enums.SegmentType.AGENT_FLOW_BUTTON, id=section_key)
+        self.label = label
+        self.agent_workflow_node_name = agent_workflow_node_name
+
+
+@dataclasses.dataclass
+class ImageUrlSegment(Segment):
+    """
+    A segment that an agent can return to render an image.
+
+    Args:
+        segment (str): The url of the image to be displayed.
+    """
+
+    segment: str
+
+    def __init__(self, url: str, section_key: str = None):
+        super().__init__(type=enums.SegmentType.IMAGE_URL, id=section_key)
+        self.segment = url
+
+
+@dataclasses.dataclass
+class TextSegment(Segment):
+    """
+    A segment that an agent can return to render text.
+
+    Args:
+        segment (str): The text to be displayed.
+    """
+
+    segment: str
+
+    def __init__(self, text: str, section_key: str = None):
+        super().__init__(type=enums.SegmentType.TEXT, id=section_key)
+        self.segment = text

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/api_client_utils.py

@@ -57,22 +57,26 @@ class StreamingHandler(str):
 
     @classmethod
     def process_streaming_data(cls, value, context, section_key, data_type):
-        if section_key and hasattr(context, 'streamed_section_response') and isinstance(context.streamed_section_response, list):
-            entry_exists = False
-            for i, item in enumerate(context.streamed_section_response):
-                if item['id'] == section_key:
-                    if ((isinstance(context.streamed_section_response[i]['contents'], str) and isinstance(value, str)) or
-                       (isinstance(context.streamed_section_response[i]['contents'], list) and isinstance(value, list))):
-                        context.streamed_section_response[i]['contents'] += value
-                    else:
-                        context.streamed_section_response[i]['contents'] = value
-                    entry_exists = True
-                    break
-            if not entry_exists:
-                context.streamed_section_response.append(
-                    {'id': section_key, 'type': data_type, 'mime_type': 'text/plain', 'contents': value})
-        elif hasattr(context, 'streamed_response') and isinstance(context.streamed_response, list) and isinstance(value, str):
-            context.streamed_response.append(value)
+        if hasattr(context, 'streamed_section_response') and hasattr(context, 'streamed_response'):
+            if data_type == 'text':
+                if section_key:
+                    entry_exists = False
+                    for i, item in enumerate(context.streamed_section_response):
+                        if item['id'] == section_key:
+                            if ((isinstance(context.streamed_section_response[i]['contents'], str) and isinstance(value, str)) or
+                               (isinstance(context.streamed_section_response[i]['contents'], list) and isinstance(value, list))):
+                                context.streamed_section_response[i]['contents'] += value
+                            else:
+                                context.streamed_section_response[i]['contents'] = value
+                            entry_exists = True
+                            break
+                    if not entry_exists:
+                        context.streamed_section_response.append(
+                            {'id': section_key, 'type': data_type, 'mime_type': 'text/plain', 'contents': value})
+                else:
+                    context.streamed_response.append(value)
+            elif data_type == 'segment':
+                context.streamed_section_response.append(value)
 
 
 def get_object_from_context(client, context, variable_name, return_type):
@@ -178,6 +182,7 @@ def load_as_pandas_from_avro_files(files: List[str], download_method: Callable,
 class StreamType(Enum):
     MESSAGE = 'message'
     SECTION_OUTPUT = 'section_output'
+    SEGMENT = 'segment'
 
 
 class DocstoreUtils:

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/client.py

@@ -39,13 +39,14 @@ from .api_class import (
     ForecastingMonitorConfig, IncrementalDatabaseConnectorConfig, LLMName,
     MemorySize, MergeConfig, OperatorConfig, ParsingConfig,
     PredictionArguments, ProblemType, ProjectFeatureGroupConfig,
-    PythonFunctionType, SamplingConfig, StreamingConnectorDatasetConfig,
-    TrainingConfig, VectorStoreConfig, WorkflowGraph,
-    get_clean_function_source_code
+    PythonFunctionType, SamplingConfig, Segment,
+    StreamingConnectorDatasetConfig, TrainingConfig, VectorStoreConfig,
+    WorkflowGraph, get_clean_function_source_code
 )
 from .api_class.abstract import get_clean_function_source_code, snake_case
 from .api_class.ai_agents import WorkflowGraph
 from .api_class.blob_input import Blob, BlobInput
+from .api_class.segments import Segment
 from .api_client_utils import (
     INVALID_PANDAS_COLUMN_NAME_CHARACTERS, StreamingHandler, StreamType,
     clean_column_name, get_object_from_context
@@ -265,18 +266,18 @@ class AgentResponse:
         self.data_list = []
         self.section_data_list = []
         for arg in args:
-            if isinstance(arg, Blob) or _is_json_serializable(arg):
+            if isinstance(arg, Blob) or _is_json_serializable(arg) or isinstance(arg, Segment):
                 self.data_list.append(arg)
             else:
                 raise Exception(
-                    'AgentResponse can only contain Blob or json serializable objects')
+                    'AgentResponse can only contain Blob, Segment or json serializable objects')
 
         for key, value in kwargs.items():
-            if isinstance(value, Blob) or _is_json_serializable(value):
+            if isinstance(value, Blob) or _is_json_serializable(value) or isinstance(value, Segment):
                 self.section_data_list.append({key: value})
             else:
                 raise Exception(
-                    'AgentResponse can only contain Blob or json serializable objects')
+                    'AgentResponse can only contain Blob, Segment or json serializable objects')
 
 
 class ClientOptions:
@@ -592,9 +593,9 @@ class BaseApiClient:
         client_options (ClientOptions): Optional API client configurations
         skip_version_check (bool): If true, will skip checking the server's current API version on initializing the client
     """
-    client_version = '1.3.4'
+    client_version = '1.3.5'
 
-    def __init__(self, api_key: str = None, server: str = None, client_options: ClientOptions = None, skip_version_check: bool = False):
+    def __init__(self, api_key: str = None, server: str = None, client_options: ClientOptions = None, skip_version_check: bool = False, include_tb: bool = False):
         self.api_key = api_key
         if self.api_key is None:
             self.api_key = os.getenv('ABACUS_API_KEY')
@@ -636,6 +637,19 @@ class BaseApiClient:
             except Exception:
                 logging.error(
                     f'Failed get the current API version from Abacus.AI ({self.server or DEFAULT_SERVER}/api/v0/version)')
+        # Modify traceback
+        if not include_tb:
+            excepthook = sys.excepthook
+
+            def modify_tb_excepthook(type, value, tb):
+                import abacusai
+                pylibdir = os.path.dirname(abacusai.__file__)
+                tb_itr = tb
+                while not (tb_itr.tb_next is None or tb_itr.tb_next.tb_frame.f_code.co_filename.startswith(pylibdir)):
+                    tb_itr = tb_itr.tb_next
+                tb_itr.tb_next = None
+                excepthook(type, value, tb)
+            sys.excepthook = modify_tb_excepthook
 
     def _get_prediction_endpoint(self, deployment_id: str, deployment_token: str):
         if self.prediction_endpoint:
@@ -3718,7 +3732,7 @@ class ApiClient(ReadOnlyClient):
                 request_id, caller, message=message, extra_args=extra_args, proxy_caller=proxy_caller)
         return StreamingHandler(message, _request_context)
 
-    def stream_section_output(self, section_key: str, value: Any, value_type: str = 'text') -> None:
+    def stream_section_output(self, section_key: str, value: str) -> None:
         """
         Streams value corresponding to a particular section to the current request context. Applicable within a AIAgent execute function.
         If the request is from the abacus.ai app, the response will be streamed to the UI. otherwise would be logged info if used from notebook or python script.
@@ -3726,14 +3740,13 @@ class ApiClient(ReadOnlyClient):
         Args:
             section_key (str): The section key to which the output corresponds.
             value (Any): The output contents.
-            value_type (str): The mime type of the output contents.
         """
         request_id = self._get_agent_app_request_id()
         caller = self._get_agent_async_app_caller()
         proxy_caller = self._is_proxy_app_caller()
         if _is_json_serializable(value):
             message_args = {'id': section_key,
-                            'type': value_type, 'mime_type': 'text/plain'}
+                            'type': 'text', 'mime_type': 'text/plain'}
         else:
             raise ValueError('The value is not json serializable')
         if request_id and caller:
@@ -3744,7 +3757,28 @@ class ApiClient(ReadOnlyClient):
                     {'agent_workflow_node_id': _request_context.agent_workflow_node_id})
             self._call_aiagent_app_send_message(
                 request_id, caller, message=value, message_args=message_args, extra_args=extra_args, proxy_caller=proxy_caller)
-        return StreamingHandler(value, _request_context, section_key=section_key, data_type=value_type)
+        return StreamingHandler(value, _request_context, section_key=section_key)
+
+    def stream_segment(self, segment: Segment):
+        """
+        Streams a segment to the current request context. Applicable within a AIAgent execute function.
+        If the request is from the abacus.ai app, the response will be streamed to the UI. otherwise would be logged info if used from notebook or python script.
+
+        Args:
+            segment (Segment): The segment to be streamed.
+        """
+        request_id = self._get_agent_app_request_id()
+        caller = self._get_agent_async_app_caller()
+        proxy_caller = self._is_proxy_app_caller()
+        if request_id and caller:
+            segment = segment.to_dict()
+            extra_args = {'stream_type': StreamType.SEGMENT.value}
+            if hasattr(_request_context, 'agent_workflow_node_id'):
+                extra_args.update(
+                    {'agent_workflow_node_id': _request_context.agent_workflow_node_id})
+            self._call_aiagent_app_send_message(
+                request_id, caller, segment=segment, extra_args=extra_args, proxy_caller=proxy_caller)
+        return StreamingHandler(segment, _request_context, data_type='segment')
 
     def _stream_llm_call(self, section_key=None, **kwargs):
         request_id = self._get_agent_app_request_id()
@@ -3766,7 +3800,7 @@ class ApiClient(ReadOnlyClient):
                 {'agent_workflow_node_id': _request_context.agent_workflow_node_id})
         return self._call_aiagent_app_send_message(request_id, caller, llm_args=kwargs, message_args=message_args, extra_args=extra_args, proxy_caller=proxy_caller)
 
-    def _call_aiagent_app_send_message(self, request_id, caller, message=None, llm_args=None, message_args=None, extra_args=None, proxy_caller=False):
+    def _call_aiagent_app_send_message(self, request_id, caller, message=None, segment=None, llm_args=None, message_args=None, extra_args=None, proxy_caller=False):
         """
         Calls the AI Agent app send message endpoint.
 
@@ -3788,6 +3822,8 @@ class ApiClient(ReadOnlyClient):
         body = {'requestId': request_id}
         if message:
             body['message'] = message
+        elif segment:
+            body['segment'] = segment
         elif llm_args:
             body['llmArgs'] = llm_args
         else:
@@ -7050,7 +7086,7 @@ Creates a new feature group defined as the union of other feature group versions
             deployment_id, deployment_token) if deployment_token else None
         return self._call_api('executeAgent', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'arguments': arguments, 'keywordArguments': keyword_arguments}, server_override=prediction_url, timeout=1500)
 
-    def execute_conversation_agent(self, deployment_token: str, deployment_id: str, arguments: list = None, keyword_arguments: dict = None, deployment_conversation_id: str = None, external_session_id: str = None, regenerate: bool = False, doc_infos: list = None) -> Dict:
+    def execute_conversation_agent(self, deployment_token: str, deployment_id: str, arguments: list = None, keyword_arguments: dict = None, deployment_conversation_id: str = None, external_session_id: str = None, regenerate: bool = False, doc_infos: list = None, agent_workflow_node_id: str = None) -> Dict:
         """Executes a deployed AI agent function using the arguments as keyword arguments to the agent execute function.
 
         Args:
@@ -7061,10 +7097,11 @@ Creates a new feature group defined as the union of other feature group versions
             deployment_conversation_id (str): A unique string identifier for the deployment conversation used for the conversation.
             external_session_id (str): A unique string identifier for the session used for the conversation. If both deployment_conversation_id and external_session_id are not provided, a new session will be created.
             regenerate (bool): If True, will regenerate the response from the last query.
-            doc_infos (list): An optional list of documents use for the conversation. A keyword 'doc_id' is expected to be present in each document for retrieving contents from docstore."""
+            doc_infos (list): An optional list of documents use for the conversation. A keyword 'doc_id' is expected to be present in each document for retrieving contents from docstore.
+            agent_workflow_node_id (str): An optional agent workflow node id to trigger agent execution from an intermediate node."""
         prediction_url = self._get_prediction_endpoint(
             deployment_id, deployment_token) if deployment_token else None
-        return self._call_api('executeConversationAgent', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'arguments': arguments, 'keywordArguments': keyword_arguments, 'deploymentConversationId': deployment_conversation_id, 'externalSessionId': external_session_id, 'regenerate': regenerate, 'docInfos': doc_infos}, server_override=prediction_url)
+        return self._call_api('executeConversationAgent', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'arguments': arguments, 'keywordArguments': keyword_arguments, 'deploymentConversationId': deployment_conversation_id, 'externalSessionId': external_session_id, 'regenerate': regenerate, 'docInfos': doc_infos, 'agentWorkflowNodeId': agent_workflow_node_id}, server_override=prediction_url)
 
     def lookup_matches(self, deployment_token: str, deployment_id: str, data: str = None, filters: dict = None, num: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None, max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None, filter_clause: str = None, crowding_limits: Dict = None) -> List[DocumentRetrieverLookupResult]:
         """Lookup document retrievers and return the matching documents from the document retriever deployed with given query.

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/deployment_conversation.py

@@ -17,10 +17,11 @@ class DeploymentConversation(AbstractApiClass):
             regenerateAttempt (int): The sequence number of regeneration. Not regenerated if 0.
             externalApplicationId (str): The external application id associated with the deployment conversation.
             unusedDocumentUploadIds (list[str]): The list of unused document upload ids associated with the deployment conversation.
+            conversationWarning (str): Extra text associated with the deployment conversation (to show it at the bottom of chatbot)
             history (DeploymentConversationEvent): The history of the deployment conversation.
     """
 
-    def __init__(self, client, deploymentConversationId=None, name=None, deploymentId=None, createdAt=None, lastEventCreatedAt=None, externalSessionId=None, regenerateAttempt=None, externalApplicationId=None, unusedDocumentUploadIds=None, history={}):
+    def __init__(self, client, deploymentConversationId=None, name=None, deploymentId=None, createdAt=None, lastEventCreatedAt=None, externalSessionId=None, regenerateAttempt=None, externalApplicationId=None, unusedDocumentUploadIds=None, conversationWarning=None, history={}):
         super().__init__(client, deploymentConversationId)
         self.deployment_conversation_id = deploymentConversationId
         self.name = name
@@ -31,13 +32,14 @@ class DeploymentConversation(AbstractApiClass):
         self.regenerate_attempt = regenerateAttempt
         self.external_application_id = externalApplicationId
         self.unused_document_upload_ids = unusedDocumentUploadIds
+        self.conversation_warning = conversationWarning
         self.history = client._build_class(
             DeploymentConversationEvent, history)
         self.deprecated_keys = {}
 
     def __repr__(self):
         repr_dict = {f'deployment_conversation_id': repr(self.deployment_conversation_id), f'name': repr(self.name), f'deployment_id': repr(self.deployment_id), f'created_at': repr(self.created_at), f'last_event_created_at': repr(self.last_event_created_at), f'external_session_id': repr(
-            self.external_session_id), f'regenerate_attempt': repr(self.regenerate_attempt), f'external_application_id': repr(self.external_application_id), f'unused_document_upload_ids': repr(self.unused_document_upload_ids), f'history': repr(self.history)}
+            self.external_session_id), f'regenerate_attempt': repr(self.regenerate_attempt), f'external_application_id': repr(self.external_application_id), f'unused_document_upload_ids': repr(self.unused_document_upload_ids), f'conversation_warning': repr(self.conversation_warning), f'history': repr(self.history)}
         class_name = "DeploymentConversation"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
@@ -51,7 +53,7 @@ class DeploymentConversation(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'deployment_conversation_id': self.deployment_conversation_id, 'name': self.name, 'deployment_id': self.deployment_id, 'created_at': self.created_at, 'last_event_created_at': self.last_event_created_at, 'external_session_id': self.external_session_id,
-                'regenerate_attempt': self.regenerate_attempt, 'external_application_id': self.external_application_id, 'unused_document_upload_ids': self.unused_document_upload_ids, 'history': self._get_attribute_as_dict(self.history)}
+                'regenerate_attempt': self.regenerate_attempt, 'external_application_id': self.external_application_id, 'unused_document_upload_ids': self.unused_document_upload_ids, 'conversation_warning': self.conversation_warning, 'history': self._get_attribute_as_dict(self.history)}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}
 
     def get(self, external_session_id: str = None, deployment_id: str = None, deployment_token: str = None, filter_intermediate_conversation_events: bool = True, get_unused_document_uploads: bool = False):

{abacusai-1.3.4 → abacusai-1.3.5}/abacusai/model.py

@@ -4,6 +4,7 @@ from . import api_class
 from .api_class import AgentInterface, TrainingConfig, WorkflowGraph
 from .code_source import CodeSource
 from .database_connector import DatabaseConnector
+from .feature_group import FeatureGroup
 from .model_location import ModelLocation
 from .model_version import ModelVersion
 from .refresh_schedule import RefreshSchedule
@@ -44,16 +45,16 @@ class Model(AbstractApiClass):
             useGpu (bool): If this model uses gpu.
             notebookId (str): The notebook associated with this model.
             trainingRequired (bool): If training is required to keep the model up-to-date.
-            dataLlmFeatureGroups (list[featuregroup]): List of feature groups used by the model for queries
             latestModelVersion (ModelVersion): The latest model version.
             location (ModelLocation): Location information for models that are imported.
             refreshSchedules (RefreshSchedule): List of refresh schedules that indicate when the next model version will be trained
             codeSource (CodeSource): If a python model, information on the source code
             databaseConnector (DatabaseConnector): Database connector used by the model.
+            dataLlmFeatureGroups (FeatureGroup): List of feature groups used by the model for queries
             modelConfig (TrainingConfig): The training config options used to train this model.
     """
 
-    def __init__(self, client, name=None, modelId=None, modelConfigType=None, modelPredictionConfig=None, createdAt=None, projectId=None, shared=None, sharedAt=None, trainFunctionName=None, predictFunctionName=None, predictManyFunctionName=None, initializeFunctionName=None, trainingInputTables=None, sourceCode=None, cpuSize=None, memory=None, trainingFeatureGroupIds=None, algorithmModelConfigs=None, trainingVectorStoreVersions=None, documentRetrievers=None, documentRetrieverIds=None, isPythonModel=None, defaultAlgorithm=None, customAlgorithmConfigs=None, restrictedAlgorithms=None, useGpu=None, notebookId=None, trainingRequired=None, dataLlmFeatureGroups=None, location={}, refreshSchedules={}, codeSource={}, databaseConnector={}, latestModelVersion={}, modelConfig={}):
+    def __init__(self, client, name=None, modelId=None, modelConfigType=None, modelPredictionConfig=None, createdAt=None, projectId=None, shared=None, sharedAt=None, trainFunctionName=None, predictFunctionName=None, predictManyFunctionName=None, initializeFunctionName=None, trainingInputTables=None, sourceCode=None, cpuSize=None, memory=None, trainingFeatureGroupIds=None, algorithmModelConfigs=None, trainingVectorStoreVersions=None, documentRetrievers=None, documentRetrieverIds=None, isPythonModel=None, defaultAlgorithm=None, customAlgorithmConfigs=None, restrictedAlgorithms=None, useGpu=None, notebookId=None, trainingRequired=None, location={}, refreshSchedules={}, codeSource={}, databaseConnector={}, dataLlmFeatureGroups={}, latestModelVersion={}, modelConfig={}):
         super().__init__(client, modelId)
         self.name = name
         self.model_id = modelId
@@ -83,13 +84,14 @@ class Model(AbstractApiClass):
         self.use_gpu = useGpu
         self.notebook_id = notebookId
         self.training_required = trainingRequired
-        self.data_llm_feature_groups = dataLlmFeatureGroups
         self.location = client._build_class(ModelLocation, location)
         self.refresh_schedules = client._build_class(
             RefreshSchedule, refreshSchedules)
         self.code_source = client._build_class(CodeSource, codeSource)
         self.database_connector = client._build_class(
             DatabaseConnector, databaseConnector)
+        self.data_llm_feature_groups = client._build_class(
+            FeatureGroup, dataLlmFeatureGroups)
         self.latest_model_version = client._build_class(
             ModelVersion, latestModelVersion)
         self.model_config = client._build_class(getattr(
@@ -98,7 +100,7 @@ class Model(AbstractApiClass):
 
     def __repr__(self):
         repr_dict = {f'name': repr(self.name), f'model_id': repr(self.model_id), f'model_config_type': repr(self.model_config_type), f'model_prediction_config': repr(self.model_prediction_config), f'created_at': repr(self.created_at), f'project_id': repr(self.project_id), f'shared': repr(self.shared), f'shared_at': repr(self.shared_at), f'train_function_name': repr(self.train_function_name), f'predict_function_name': repr(self.predict_function_name), f'predict_many_function_name': repr(self.predict_many_function_name), f'initialize_function_name': repr(self.initialize_function_name), f'training_input_tables': repr(self.training_input_tables), f'source_code': repr(self.source_code), f'cpu_size': repr(self.cpu_size), f'memory': repr(self.memory), f'training_feature_group_ids': repr(self.training_feature_group_ids), f'algorithm_model_configs': repr(self.algorithm_model_configs),
-                     f'training_vector_store_versions': repr(self.training_vector_store_versions), f'document_retrievers': repr(self.document_retrievers), f'document_retriever_ids': repr(self.document_retriever_ids), f'is_python_model': repr(self.is_python_model), f'default_algorithm': repr(self.default_algorithm), f'custom_algorithm_configs': repr(self.custom_algorithm_configs), f'restricted_algorithms': repr(self.restricted_algorithms), f'use_gpu': repr(self.use_gpu), f'notebook_id': repr(self.notebook_id), f'training_required': repr(self.training_required), f'data_llm_feature_groups': repr(self.data_llm_feature_groups), f'location': repr(self.location), f'refresh_schedules': repr(self.refresh_schedules), f'code_source': repr(self.code_source), f'database_connector': repr(self.database_connector), f'latest_model_version': repr(self.latest_model_version), f'model_config': repr(self.model_config)}
+                     f'training_vector_store_versions': repr(self.training_vector_store_versions), f'document_retrievers': repr(self.document_retrievers), f'document_retriever_ids': repr(self.document_retriever_ids), f'is_python_model': repr(self.is_python_model), f'default_algorithm': repr(self.default_algorithm), f'custom_algorithm_configs': repr(self.custom_algorithm_configs), f'restricted_algorithms': repr(self.restricted_algorithms), f'use_gpu': repr(self.use_gpu), f'notebook_id': repr(self.notebook_id), f'training_required': repr(self.training_required), f'location': repr(self.location), f'refresh_schedules': repr(self.refresh_schedules), f'code_source': repr(self.code_source), f'database_connector': repr(self.database_connector), f'data_llm_feature_groups': repr(self.data_llm_feature_groups), f'latest_model_version': repr(self.latest_model_version), f'model_config': repr(self.model_config)}
         class_name = "Model"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
@@ -112,7 +114,7 @@ class Model(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'name': self.name, 'model_id': self.model_id, 'model_config_type': self.model_config_type, 'model_prediction_config': self.model_prediction_config, 'created_at': self.created_at, 'project_id': self.project_id, 'shared': self.shared, 'shared_at': self.shared_at, 'train_function_name': self.train_function_name, 'predict_function_name': self.predict_function_name, 'predict_many_function_name': self.predict_many_function_name, 'initialize_function_name': self.initialize_function_name, 'training_input_tables': self.training_input_tables, 'source_code': self.source_code, 'cpu_size': self.cpu_size, 'memory': self.memory, 'training_feature_group_ids': self.training_feature_group_ids, 'algorithm_model_configs': self.algorithm_model_configs, 'training_vector_store_versions': self.training_vector_store_versions, 'document_retrievers': self.document_retrievers,
-                'document_retriever_ids': self.document_retriever_ids, 'is_python_model': self.is_python_model, 'default_algorithm': self.default_algorithm, 'custom_algorithm_configs': self.custom_algorithm_configs, 'restricted_algorithms': self.restricted_algorithms, 'use_gpu': self.use_gpu, 'notebook_id': self.notebook_id, 'training_required': self.training_required, 'data_llm_feature_groups': self.data_llm_feature_groups, 'location': self._get_attribute_as_dict(self.location), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules), 'code_source': self._get_attribute_as_dict(self.code_source), 'database_connector': self._get_attribute_as_dict(self.database_connector), 'latest_model_version': self._get_attribute_as_dict(self.latest_model_version), 'model_config': self._get_attribute_as_dict(self.model_config)}
+                'document_retriever_ids': self.document_retriever_ids, 'is_python_model': self.is_python_model, 'default_algorithm': self.default_algorithm, 'custom_algorithm_configs': self.custom_algorithm_configs, 'restricted_algorithms': self.restricted_algorithms, 'use_gpu': self.use_gpu, 'notebook_id': self.notebook_id, 'training_required': self.training_required, 'location': self._get_attribute_as_dict(self.location), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules), 'code_source': self._get_attribute_as_dict(self.code_source), 'database_connector': self._get_attribute_as_dict(self.database_connector), 'data_llm_feature_groups': self._get_attribute_as_dict(self.data_llm_feature_groups), 'latest_model_version': self._get_attribute_as_dict(self.latest_model_version), 'model_config': self._get_attribute_as_dict(self.model_config)}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}
 
     def describe_train_test_data_split_feature_group(self):