abacusai 1.2.6__tar.gz → 1.2.8__tar.gz

{abacusai-1.2.6/abacusai.egg-info → abacusai-1.2.8}/PKG-INFO

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

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_class/abstract.py

@@ -171,20 +171,22 @@ class ApiClass(ABC):
                 input_dict = {snake_case(k): v for k, v in input_dict.items()}
             if not cls._support_kwargs:
                 # only use keys that are valid fields in the ApiClass
-                field_names = set((field.name) for field in dataclasses.fields(cls))
+                field_names = set((field.name) for field in dataclasses.fields(type(obj) if obj else cls))
                 input_dict = {k: v for k, v in input_dict.items() if k in field_names}
         if obj is None:
             obj = cls(**input_dict)
 
-        for attr_name, attr_type in get_type_hints(cls).items():
-            if attr_name in input_dict and inspect.isclass(attr_type) and issubclass(attr_type, ApiClass):
+        for attr_name, attr_type in get_type_hints(type(obj)).items():
+            if attr_name in input_dict and isinstance(input_dict[attr_name], dict) and inspect.isclass(attr_type) and issubclass(attr_type, ApiClass):
                 setattr(obj, attr_name, attr_type.from_dict(input_dict[attr_name]))
             elif attr_name in input_dict and get_origin(attr_type) is list and attr_type.__args__ and inspect.isclass(attr_type.__args__[0]) and issubclass(attr_type.__args__[0], ApiClass):
                 class_type = attr_type.__args__[0]
                 if isinstance(input_dict[attr_name], list):
-                    setattr(obj, attr_name, [class_type.from_dict(item) for item in input_dict[attr_name]])
+                    if not all(isinstance(item, dict) or isinstance(item, class_type) for item in input_dict[attr_name]):
+                        raise ValueError(attr_name, f'Expected list of {class_type} or dictionary for {attr_name}')
+                    setattr(obj, attr_name, [item if isinstance(item, class_type) else class_type.from_dict(item) for item in input_dict[attr_name]])
                 else:
-                    raise ValueError(f'Expected list for {attr_name} but got {type(input_dict[attr_name])}')
+                    raise ValueError(attr_name, f'Expected list for {attr_name} but got {type(input_dict[attr_name])}')
 
         return obj
 
@@ -200,7 +202,7 @@ class _ApiClassFactory(ABC):
         support_kwargs = cls.config_abstract_class and cls.config_abstract_class._support_kwargs
         is_upper_snake_case_keys = cls.config_abstract_class and cls.config_abstract_class._upper_snake_case_keys
         config_class_key = upper_snake_case(cls.config_class_key) if is_upper_snake_case_keys else cls.config_class_key
-        # Logic here is that the we keep the config_class_key in snake_case if _upper_snake_case_keys is False else we convert it to upper_snake_case
+        # Logic here is that the we keep the config_class_key in snake_case if _upper_snake_case_keys False else we convert it to upper_snake_case
         # if _upper_snake_case_keys is False then we check in both casing: 1. snake_case and 2. camel_case
         if not is_upper_snake_case_keys and config_class_key not in config and camel_case(config_class_key) in config:
             config_class_key = camel_case(config_class_key)

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_class/ai_agents.py

@@ -28,7 +28,7 @@ class WorkflowNodeInputSchema(ApiClass):
     A react-jsonschema-form conformant schema for workflow node input.
 
     Args:
-        json_schema (dict): The json schema for the input conformant to react-jsonschema-form specification.
+        json_schema (dict): The json schema for the input conformant to react-jsonschema-form specification. Must define keys like "title", "type" and "properties".
         ui_schema (dict): The ui schema for the input conformant to react-jsonschema-form specification.
     """
     json_schema: dict
@@ -76,7 +76,7 @@ class WorkflowNodeInputMapping(ApiClass):
     A mapping of input to a workflow node.
 
     Args:
-        name (str): The name of the input.
+        name (str): The name of the input variable of the node function.
         variable_type (WorkflowNodeInputType): The type of the input.
         variable_source (str): The name of the node this variable is sourced from.
                                If the type is `WORKFLOW_VARIABLE`, the value given by the source node will be directly used.
@@ -140,8 +140,8 @@ class WorkflowGraphNode(ApiClass):
 
     Args:
         name (str): A unique name for the workflow node.
-        input_mappings (List[WorkflowNodeInputMapping]): List of input mappings for the node.
-        output_mappings (List[WorkflowNodeOutputMapping]): List of output mappings for the node.
+        input_mappings (List[WorkflowNodeInputMapping]): List of input mappings for the node. Each arg/kwarg of the node function should have a corresponding input mapping.
+        output_mappings (List[WorkflowNodeOutputMapping]): List of output mappings for the node. Each field in the returned dict/AgentResponse must have a corresponding output mapping.
         function (callable): The callable node function reference.
         input_schema (WorkflowNodeInputSchema): The react json schema for the input form if applicable.
         output_schema (WorkflowNodeOutputSchema): The react json schema for the output if applicable.
@@ -161,8 +161,8 @@ class WorkflowGraphNode(ApiClass):
         self.name = name
         self.input_mappings = input_mappings
         self.output_mappings = output_mappings
-        self.input_schema = input_schema if input_schema else {}
-        self.output_schema = output_schema if output_schema else {}
+        self.input_schema = input_schema if input_schema else WorkflowNodeInputSchema({})
+        self.output_schema = output_schema if output_schema else WorkflowNodeOutputSchema({})
         self.package_requirements = package_requirements if package_requirements else []
 
     def to_dict(self):
@@ -212,7 +212,7 @@ class WorkflowGraphEdge(ApiClass):
 @dataclasses.dataclass
 class WorkflowGraph(ApiClass):
     """
-    An Agent workflow graph.
+    An Agent workflow graph. The edges define the node invokation order. The workflow must follow linear invokation order.
 
     Args:
         nodes (List[WorkflowGraphNode]): A list of nodes in the workflow graph.

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_class/batch_prediction.py

@@ -54,10 +54,8 @@ class NamedEntityExtractionBatchPredictionArgs(BatchPredictionArgs):
 
     Args:
        for_eval (bool): If True, the test fold which was created during training and used for metrics calculation will be used as input data. These predictions are hence, used for model evaluation.
-       verbose_predictions (bool): Return prediction inputs, predicted annotations and token label probabilities.
     """
     for_eval: bool = dataclasses.field(default=None)
-    verbose_predictions: bool = dataclasses.field(default=None)
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.NAMED_ENTITY_EXTRACTION

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_class/dataset_application_connector.py

@@ -144,7 +144,12 @@ class SharepointDatasetConfig(DatasetConfig):
 class ZendeskDatasetConfig(DatasetConfig):
     """
     Dataset config for Zendesk Application Connector
+
+    Args:
+        location (str): The regex location of the files to fetch
     """
+    location: str = dataclasses.field(default=None)
+
     def __post_init__(self):
         self.application_connector_type = enums.ApplicationConnectorType.ZENDESK
 

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_class/enums.py

@@ -362,6 +362,7 @@ class ApplicationConnectorType(ApiEnum):
     ABACUSUSAGEMETRICS = 'ABACUSUSAGEMETRICS'
     MICROSOFTAUTH = 'MICROSOFTAUTH'
     FRESHSERVICE = 'FRESHSERVICE'
+    ZENDESKSUNSHINEMESSAGING = 'zendesksunshinemessaging'
 
 
 class PythonFunctionArgumentType(ApiEnum):
@@ -412,6 +413,7 @@ class LLMName(ApiEnum):
     OPENAI_GPT3_5 = 'OPENAI_GPT3_5'
     OPENAI_GPT3_5_TEXT = 'OPENAI_GPT3_5_TEXT'
     LLAMA3_LARGE_CHAT = 'LLAMA3_LARGE_CHAT'
+    GROQ_LLAMA3_LARGE_CHAT = 'GROQ_LLAMA3_LARGE_CHAT'
     CLAUDE_V2_1 = 'CLAUDE_V2_1'
     CLAUDE_V3_OPUS = 'CLAUDE_V3_OPUS'
     CLAUDE_V3_SONNET = 'CLAUDE_V3_SONNET'
@@ -541,3 +543,8 @@ class AgentInterface(ApiEnum):
     # Duplicated in reainternal.enums, both should be kept in sync
     DEFAULT = 'DEFAULT'
     CHAT = 'CHAT'
+
+
+class ProjectConfigType(ApiEnum):
+    CONSTRAINTS = 'CONSTRAINTS'
+    REVIEW_MODE = 'REVIEW_MODE'

abacusai-1.2.8/abacusai/api_class/project.py

@@ -0,0 +1,110 @@
+import dataclasses
+from typing import List, Optional
+
+from . import enums
+from .abstract import ApiClass, _ApiClassFactory
+
+
+@dataclasses.dataclass
+class FeatureMappingConfig(ApiClass):
+    """
+    Feature mapping configuration for a feature group type.
+
+    Args:
+        feature_name (str): The name of the feature in the feature group.
+        feature_mapping (str): The desired feature mapping for the feature.
+        nested_feature_name (str): The name of the nested feature in the feature group.
+    """
+    feature_name: str
+    feature_mapping: str = dataclasses.field(default=None)
+    nested_feature_name: str = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class ProjectFeatureGroupTypeMappingsConfig(ApiClass):
+    """
+    Project feature group type mappings.
+
+    Args:
+        feature_group_id (str): The unique identifier for the feature group.
+        feature_group_type (str): The feature group type.
+        feature_mappings (List[FeatureMappingConfig]): The feature mappings for the feature group.
+    """
+    feature_group_id: str
+    feature_group_type: str = dataclasses.field(default=None)
+    feature_mappings: List[FeatureMappingConfig] = dataclasses.field(default=list)
+
+    @classmethod
+    def from_dict(cls, input_dict: dict):
+        inst = cls(**input_dict)
+        inst.feature_mappings = [FeatureMappingConfig.from_dict(fm) for fm in input_dict.get('feature_mappings') or []]
+        return inst
+
+
+@dataclasses.dataclass
+class ConstraintConfig(ApiClass):
+    """
+    Constraint configuration.
+
+    Args:
+        constant (float): The constant value for the constraint.
+        operator (str): The operator for the constraint. Could be 'EQ', 'LE', 'GE'
+        enforcement (str): The enforcement for the constraint. Could be 'HARD' or 'SOFT'
+        code (str): The code for the constraint.
+        penalty (float): The penalty for violating the constraint.
+    """
+    constant: float
+    operator: str
+    enforcement: str
+    code: Optional[str] = dataclasses.field(default=None)
+    penalty: Optional[float] = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class ProjectFeatureGroupConfig(ApiClass):
+    """
+    An abstract class for project feature group configuration.
+    """
+    type: enums.ProjectConfigType = dataclasses.field(default=None, repr=False, init=False)
+
+    @classmethod
+    def _get_builder(cls):
+        return _ProjectFeatureGroupConfigFactory
+
+
+@dataclasses.dataclass
+class ConstraintProjectFeatureGroupConfig(ProjectFeatureGroupConfig):
+    """
+    Constraint project feature group configuration.
+
+    Args:
+        constraints (List[ConstraintConfig]): The constraint for the feature group. Should be a list of one ConstraintConfig.
+    """
+    constraints: List[ConstraintConfig]
+
+    def __post_init__(self):
+        self.type = enums.ProjectConfigType.CONSTRAINTS
+
+
+@dataclasses.dataclass
+class ReviewModeProjectFeatureGroupConfig(ProjectFeatureGroupConfig):
+    """
+    Review mode project feature group configuration.
+
+    Args:
+        is_review_mode (bool): The review mode for the feature group.
+    """
+    is_review_mode: bool
+
+    def __post_init__(self):
+        self.type = enums.ProjectConfigType.REVIEW_MODE
+
+
+@dataclasses.dataclass
+class _ProjectFeatureGroupConfigFactory(_ApiClassFactory):
+    config_abstract_class = ProjectFeatureGroupConfig
+    config_class_key = 'type'
+    config_class_map = {
+        enums.ProjectConfigType.CONSTRAINTS: ConstraintProjectFeatureGroupConfig,
+        enums.ProjectConfigType.REVIEW_MODE: ReviewModeProjectFeatureGroupConfig
+    }

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/api_client_utils.py

@@ -190,6 +190,7 @@ class DocstoreUtils:
     LAST_PAGE = 'last_page'
     PAGE_TEXT = 'page_text'
     PAGES = 'pages'
+    CONTENT = 'content'
     TOKENS = 'tokens'
     PAGES_ZIP_METADATA = 'pages_zip_metadata'
     PAGE_DATA = 'page_data'
@@ -363,9 +364,15 @@ class DocstoreUtils:
                                  for page_no, (h, w) in enumerate(zip(height_list, width_list))]
                 result.update(
                     {cls.TOKENS: tokens, cls.METADATA: metadata_list})
+
             if cls.EXTRACTED_TEXT in group:
-                extracted_text = list(group[cls.EXTRACTED_TEXT])
-                result.update({cls.EXTRACTED_TEXT: extracted_text})
+                pagewise_extracted_text = list(group[cls.EXTRACTED_TEXT])
+                result.update({cls.EXTRACTED_TEXT: pagewise_extracted_text})
+            elif cls.TOKENS in group:
+                pagewise_extracted_text = [' '.join([(token or {}).get(
+                    cls.CONTENT) or '' for token in page_tokens or []]) for page_tokens in group[cls.TOKENS]]
+                result.update({cls.EXTRACTED_TEXT: pagewise_extracted_text})
+
             return result
 
         doc_infos = pages_df.groupby(doc_id_column).apply(

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/client.py

@@ -38,8 +38,8 @@ from .api_class import (
     DocumentRetrieverConfig, EvalArtifactType, FeatureGroupExportConfig,
     ForecastingMonitorConfig, IncrementalDatabaseConnectorConfig, LLMName,
     MergeConfig, ParsingConfig, PredictionArguments, ProblemType,
-    PythonFunctionType, SamplingConfig, TrainingConfig, WorkflowGraph,
-    get_clean_function_source_code
+    ProjectFeatureGroupConfig, PythonFunctionType, SamplingConfig,
+    TrainingConfig, 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
@@ -3894,7 +3894,7 @@ class ApiClient(ReadOnlyClient):
 
     def get_matching_documents(self, document_retriever_id: str, query: str, filters: dict = None, limit: 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) -> List[DocumentRetrieverLookupResult]:
+                               filter_clause: str = None, crowding_limits: Dict[str, int] = None) -> List[DocumentRetrieverLookupResult]:
         """Lookup document retrievers and return the matching documents from the document retriever deployed with given query.
 
         Original documents are splitted into chunks and stored in the document retriever. This lookup function will return the relevant chunks
@@ -3915,12 +3915,13 @@ class ApiClient(ReadOnlyClient):
             min_score (float): If provided, will filter out the results with score lower than the value specified.
             required_phrases (list): If provided, each result will have at least one of the phrases.
             filter_clause (str): If provided, filter the results of the query using this sql where clause.
+            crowding_limits (dict): A dictionary mapping metadata columns to the maximum number of results per unique value of the column. This is used to ensure diversity of metadata attribute values in the results. If a particular attribute value has already reached its maximum count, further results with that same attribute value will be excluded from the final result set.
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever."""
 
         deployment_token, deployment_id = self._get_doc_retriever_deployment_info(
             document_retriever_id)
-        return self.lookup_matches(deployment_token, deployment_id, query, filters, limit if limit is not None else 10, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause)
+        return self.lookup_matches(deployment_token, deployment_id, query, filters, limit if limit is not None else 10, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause, crowding_limits)
 
     def create_model_from_files(self, project_id: str, location: str, name: str = None, custom_artifact_filenames: dict = {}, model_config: dict = {}) -> Model:
         """Creates a new Model and returns Upload IDs for uploading the model artifacts.
@@ -4306,13 +4307,13 @@ class ApiClient(ReadOnlyClient):
             feature_group_type (str): The feature group type of the feature group, based on the use case under which the feature group is being created."""
         return self._call_api('addFeatureGroupToProject', 'POST', query_params={}, body={'featureGroupId': feature_group_id, 'projectId': project_id, 'featureGroupType': feature_group_type})
 
-    def set_project_feature_group_config(self, feature_group_id: str, project_id: str, project_config: dict = None):
+    def set_project_feature_group_config(self, feature_group_id: str, project_id: str, project_config: Union[dict, ProjectFeatureGroupConfig] = None):
         """Sets a feature group's project config
 
         Args:
             feature_group_id (str): Unique string identifier for the feature group.
             project_id (str): Unique string identifier for the project.
-            project_config (dict): JSON object for the feature group's project configuration."""
+            project_config (ProjectFeatureGroupConfig): Feature group's project configuration."""
         return self._call_api('setProjectFeatureGroupConfig', 'PATCH', query_params={}, body={'featureGroupId': feature_group_id, 'projectId': project_id, 'projectConfig': project_config})
 
     def remove_feature_group_from_project(self, feature_group_id: str, project_id: str):
@@ -5547,19 +5548,20 @@ Creates a new feature group defined as the union of other feature group versions
             PageData: The extracted page data."""
         return self._proxy_request('getDocstorePageData', 'POST', query_params={}, body={'docId': doc_id, 'page': page, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version}, parse_type=PageData, is_sync=True)
 
-    def get_docstore_document_data(self, doc_id: str, document_processing_config: Union[dict, DocumentProcessingConfig] = None, document_processing_version: str = None) -> DocumentData:
+    def get_docstore_document_data(self, doc_id: str, document_processing_config: Union[dict, DocumentProcessingConfig] = None, document_processing_version: str = None, return_extracted_page_text: bool = False) -> DocumentData:
         """Returns the extracted data for a document.
 
         Args:
             doc_id (str): A unique Docstore string identifier for the document.
             document_processing_config (DocumentProcessingConfig): The document processing configuration to use for returning the data. If not provided, the latest available data or the default configuration will be used.
             document_processing_version (str): The document processing version to use for returning the data. If not provided, the latest version will be used.
+            return_extracted_page_text (bool): (Optional) Whether to return list of extracted text for each page.
 
         Returns:
             DocumentData: The extracted document data."""
-        return self._call_api('getDocstoreDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version}, parse_type=DocumentData)
+        return self._call_api('getDocstoreDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version, 'returnExtractedPageText': return_extracted_page_text}, parse_type=DocumentData)
 
-    def extract_document_data(self, document: io.TextIOBase = None, doc_id: str = None, document_processing_config: Union[dict, DocumentProcessingConfig] = None, start_page: int = None, end_page: int = None) -> DocumentData:
+    def extract_document_data(self, document: io.TextIOBase = None, doc_id: str = None, document_processing_config: Union[dict, DocumentProcessingConfig] = None, start_page: int = None, end_page: int = None, return_extracted_page_text: bool = False) -> DocumentData:
         """Extracts data from a document.
 
         Args:
@@ -5568,10 +5570,11 @@ Creates a new feature group defined as the union of other feature group versions
             document_processing_config (DocumentProcessingConfig): The document processing configuration.
             start_page (int): (Optional) The starting page to extract data from. Pages are indexed starting from 0. If not provided, the first page will be used.
             end_page (int): (Optional) The last page to extract data from. Pages are indexed starting from 0. If not provided, the last page will be used.
+            return_extracted_page_text (bool): (Optional) Whether to return list of extracted text for each page.
 
         Returns:
             DocumentData: The extracted document data."""
-        return self._proxy_request('ExtractDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': json.dumps(document_processing_config), 'startPage': start_page, 'endPage': end_page}, files={'document': document}, parse_type=DocumentData)
+        return self._proxy_request('ExtractDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': json.dumps(document_processing_config), 'startPage': start_page, 'endPage': end_page, 'returnExtractedPageText': return_extracted_page_text}, files={'document': document}, parse_type=DocumentData)
 
     def get_training_config_options(self, project_id: str, feature_group_ids: List = None, for_retrain: bool = False, current_training_config: Union[dict, TrainingConfig] = None) -> List[TrainingConfigOptions]:
         """Retrieves the full initial description of the model training configuration options available for the specified project. The configuration options available are determined by the use case associated with the specified project. Refer to the [Use Case Documentation]({USE_CASES_URL}) for more information on use cases and use case-specific configuration options.
@@ -7078,7 +7081,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('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)
 
-    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) -> List[DocumentRetrieverLookupResult]:
+    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.
 
         Original documents are splitted into chunks and stored in the document retriever. This lookup function will return the relevant chunks
@@ -7100,12 +7103,13 @@ Creates a new feature group defined as the union of other feature group versions
             min_score (float): If provided, will filter out the results with score less than the value specified.
             required_phrases (list): If provided, each result will contain at least one of the phrases in the given list. The matching is whitespace and case insensitive.
             filter_clause (str): If provided, filter the results of the query using this sql where clause.
+            crowding_limits (Dict): A dictionary mapping metadata columns to the maximum number of results per unique value of the column. This is used to ensure diversity of metadata attribute values in the results. If a particular attribute value has already reached its maximum count, further results with that same attribute value will be excluded from the final result set.
 
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever."""
         prediction_url = self._get_prediction_endpoint(
             deployment_id, deployment_token) if deployment_token else None
-        return self._call_api('lookupMatches', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'data': data, 'filters': filters, 'num': num, 'resultColumns': result_columns, 'maxWords': max_words, 'numRetrievalMarginWords': num_retrieval_margin_words, 'maxWordsPerChunk': max_words_per_chunk, 'scoreMultiplierColumn': score_multiplier_column, 'minScore': min_score, 'requiredPhrases': required_phrases, 'filterClause': filter_clause}, parse_type=DocumentRetrieverLookupResult, server_override=prediction_url)
+        return self._call_api('lookupMatches', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'data': data, 'filters': filters, 'num': num, 'resultColumns': result_columns, 'maxWords': max_words, 'numRetrievalMarginWords': num_retrieval_margin_words, 'maxWordsPerChunk': max_words_per_chunk, 'scoreMultiplierColumn': score_multiplier_column, 'minScore': min_score, 'requiredPhrases': required_phrases, 'filterClause': filter_clause, 'crowdingLimits': crowding_limits}, parse_type=DocumentRetrieverLookupResult, server_override=prediction_url)
 
     def execute_agent_with_binary_data(self, deployment_token: str, deployment_id: str, arguments: list = None, keyword_arguments: dict = None, deployment_conversation_id: str = None, external_session_id: str = None, blobs: None = None) -> Dict:
         """Executes a deployed AI agent function with binary data as inputs.
@@ -7925,17 +7929,18 @@ Creates a new feature group defined as the union of other feature group versions
             list[AbacusApi]: A list of suggested Abacus APIs"""
         return self._call_api('suggestAbacusApis', 'POST', query_params={}, body={'query': query, 'verbosity': verbosity, 'limit': limit, 'includeScores': include_scores}, parse_type=AbacusApi)
 
-    def create_deployment_conversation(self, deployment_id: str, name: str, deployment_token: str = None) -> DeploymentConversation:
+    def create_deployment_conversation(self, deployment_id: str, name: str, deployment_token: str = None, external_application_id: str = None) -> DeploymentConversation:
         """Creates a deployment conversation.
 
         Args:
             deployment_id (str): The deployment this conversation belongs to.
             name (str): The name of the conversation.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in.
+            external_application_id (str): The external application id associated with the deployment conversation.
 
         Returns:
             DeploymentConversation: The deployment conversation."""
-        return self._proxy_request('createDeploymentConversation', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'name': name}, parse_type=DeploymentConversation, is_sync=True)
+        return self._proxy_request('createDeploymentConversation', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'name': name, 'externalApplicationId': external_application_id}, parse_type=DeploymentConversation, is_sync=True)
 
     def delete_deployment_conversation(self, deployment_conversation_id: str, deployment_id: str = None, deployment_token: str = None):
         """Delete a Deployment Conversation.
@@ -8259,7 +8264,10 @@ Creates a new feature group defined as the union of other feature group versions
         return self._call_api('getDocumentSnippet', 'POST', query_params={}, body={'documentRetrieverId': document_retriever_id, 'documentId': document_id, 'startWordIndex': start_word_index, 'endWordIndex': end_word_index}, parse_type=DocumentRetrieverLookupResult)
 
     def restart_document_retriever(self, document_retriever_id: str):
-        """Restart the document retriever if it is stopped.
+        """Restart the document retriever if it is stopped. This will start the deployment of the document retriever,
+
+        but will not wait for it to be ready. You need to call wait_until_ready to wait until the deployment is ready.
+
 
         Args:
             document_retriever_id (str): A unique string identifier associated with the document retriever."""

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/deployment.py

@@ -455,18 +455,19 @@ class Deployment(AbstractApiClass):
         """
         return self.client.get_feature_group_row_process_logs_by_key(self.deployment_id, primary_key_value)
 
-    def create_conversation(self, name: str, deployment_token: str = None):
+    def create_conversation(self, name: str, deployment_token: str = None, external_application_id: str = None):
         """
         Creates a deployment conversation.
 
         Args:
             name (str): The name of the conversation.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in.
+            external_application_id (str): The external application id associated with the deployment conversation.
 
         Returns:
             DeploymentConversation: The deployment conversation.
         """
-        return self.client.create_deployment_conversation(self.deployment_id, name, deployment_token)
+        return self.client.create_deployment_conversation(self.deployment_id, name, deployment_token, external_application_id)
 
     def list_conversations(self):
         """

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/deployment_conversation.py

@@ -15,10 +15,11 @@ class DeploymentConversation(AbstractApiClass):
             lastEventCreatedAt (str): The timestamp at which the most recent corresponding deployment conversation event was created at.
             externalSessionId (str): The external session id associated with the deployment conversation.
             regenerateAttempt (int): The sequence number of regeneration. Not regenerated if 0.
+            externalApplicationId (str): The external application id associated with the deployment conversation.
             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, history={}):
+    def __init__(self, client, deploymentConversationId=None, name=None, deploymentId=None, createdAt=None, lastEventCreatedAt=None, externalSessionId=None, regenerateAttempt=None, externalApplicationId=None, history={}):
         super().__init__(client, deploymentConversationId)
         self.deployment_conversation_id = deploymentConversationId
         self.name = name
@@ -27,13 +28,14 @@ class DeploymentConversation(AbstractApiClass):
         self.last_event_created_at = lastEventCreatedAt
         self.external_session_id = externalSessionId
         self.regenerate_attempt = regenerateAttempt
+        self.external_application_id = externalApplicationId
         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'history': repr(self.history)}
+        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'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])
@@ -46,8 +48,8 @@ class DeploymentConversation(AbstractApiClass):
         Returns:
             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, 'history': self._get_attribute_as_dict(self.history)}
+        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, '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):

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/deployment_conversation_event.py

@@ -27,9 +27,11 @@ class DeploymentConversationEvent(AbstractApiClass):
             agentResponse (dict): Response from the agent. Only for conversation with agents.
             error (str): The error message in case of an error.
             segments (list): The segments of the message.
+            streamedData (str): Aggregated streamed messages from the agent.
+            streamedSectionData (str): Aggregated streamed section outputs from the agent in a list.
     """
 
-    def __init__(self, client, role=None, text=None, timestamp=None, messageIndex=None, regenerateAttempt=None, modelVersion=None, searchResults=None, isUseful=None, feedback=None, feedbackType=None, docInfos=None, keywordArguments=None, inputParams=None, attachments=None, responseVersion=None, agentWorkflowNodeId=None, chatType=None, agentResponse=None, error=None, segments=None):
+    def __init__(self, client, role=None, text=None, timestamp=None, messageIndex=None, regenerateAttempt=None, modelVersion=None, searchResults=None, isUseful=None, feedback=None, feedbackType=None, docInfos=None, keywordArguments=None, inputParams=None, attachments=None, responseVersion=None, agentWorkflowNodeId=None, chatType=None, agentResponse=None, error=None, segments=None, streamedData=None, streamedSectionData=None):
         super().__init__(client, None)
         self.role = role
         self.text = text
@@ -51,11 +53,13 @@ class DeploymentConversationEvent(AbstractApiClass):
         self.agent_response = agentResponse
         self.error = error
         self.segments = segments
+        self.streamed_data = streamedData
+        self.streamed_section_data = streamedSectionData
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'role': repr(self.role), f'text': repr(self.text), f'timestamp': repr(self.timestamp), f'message_index': repr(self.message_index), f'regenerate_attempt': repr(self.regenerate_attempt), f'model_version': repr(self.model_version), f'search_results': repr(self.search_results), f'is_useful': repr(self.is_useful), f'feedback': repr(self.feedback), f'feedback_type': repr(self.feedback_type), f'doc_infos': repr(
-            self.doc_infos), f'keyword_arguments': repr(self.keyword_arguments), f'input_params': repr(self.input_params), f'attachments': repr(self.attachments), f'response_version': repr(self.response_version), f'agent_workflow_node_id': repr(self.agent_workflow_node_id), f'chat_type': repr(self.chat_type), f'agent_response': repr(self.agent_response), f'error': repr(self.error), f'segments': repr(self.segments)}
+        repr_dict = {f'role': repr(self.role), f'text': repr(self.text), f'timestamp': repr(self.timestamp), f'message_index': repr(self.message_index), f'regenerate_attempt': repr(self.regenerate_attempt), f'model_version': repr(self.model_version), f'search_results': repr(self.search_results), f'is_useful': repr(self.is_useful), f'feedback': repr(self.feedback), f'feedback_type': repr(self.feedback_type), f'doc_infos': repr(self.doc_infos), f'keyword_arguments': repr(
+            self.keyword_arguments), f'input_params': repr(self.input_params), f'attachments': repr(self.attachments), f'response_version': repr(self.response_version), f'agent_workflow_node_id': repr(self.agent_workflow_node_id), f'chat_type': repr(self.chat_type), f'agent_response': repr(self.agent_response), f'error': repr(self.error), f'segments': repr(self.segments), f'streamed_data': repr(self.streamed_data), f'streamed_section_data': repr(self.streamed_section_data)}
         class_name = "DeploymentConversationEvent"
         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])
@@ -68,6 +72,6 @@ class DeploymentConversationEvent(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'role': self.role, 'text': self.text, 'timestamp': self.timestamp, 'message_index': self.message_index, 'regenerate_attempt': self.regenerate_attempt, 'model_version': self.model_version, 'search_results': self.search_results, 'is_useful': self.is_useful, 'feedback': self.feedback, 'feedback_type': self.feedback_type, 'doc_infos': self.doc_infos,
-                'keyword_arguments': self.keyword_arguments, 'input_params': self.input_params, 'attachments': self.attachments, 'response_version': self.response_version, 'agent_workflow_node_id': self.agent_workflow_node_id, 'chat_type': self.chat_type, 'agent_response': self.agent_response, 'error': self.error, 'segments': self.segments}
+        resp = {'role': self.role, 'text': self.text, 'timestamp': self.timestamp, 'message_index': self.message_index, 'regenerate_attempt': self.regenerate_attempt, 'model_version': self.model_version, 'search_results': self.search_results, 'is_useful': self.is_useful, 'feedback': self.feedback, 'feedback_type': self.feedback_type, 'doc_infos': self.doc_infos, 'keyword_arguments': self.keyword_arguments,
+                'input_params': self.input_params, 'attachments': self.attachments, 'response_version': self.response_version, 'agent_workflow_node_id': self.agent_workflow_node_id, 'chat_type': self.chat_type, 'agent_response': self.agent_response, 'error': self.error, 'segments': self.segments, 'streamed_data': self.streamed_data, 'streamed_section_data': self.streamed_section_data}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.2.6 → abacusai-1.2.8}/abacusai/document_data.py

@@ -17,9 +17,10 @@ class DocumentData(AbstractApiClass):
             tokens (list): List of extracted tokens in the document obtained from OCR.
             metadata (list): List of metadata for each page in the document.
             pageMarkdown (list): The markdown text for the page.
+            extractedPageText (list): List of extracted text for each page in the document obtained from OCR.
     """
 
-    def __init__(self, client, docId=None, mimeType=None, pageCount=None, totalPageCount=None, extractedText=None, embeddedText=None, pages=None, tokens=None, metadata=None, pageMarkdown=None):
+    def __init__(self, client, docId=None, mimeType=None, pageCount=None, totalPageCount=None, extractedText=None, embeddedText=None, pages=None, tokens=None, metadata=None, pageMarkdown=None, extractedPageText=None):
         super().__init__(client, None)
         self.doc_id = docId
         self.mime_type = mimeType
@@ -31,11 +32,12 @@ class DocumentData(AbstractApiClass):
         self.tokens = tokens
         self.metadata = metadata
         self.page_markdown = pageMarkdown
+        self.extracted_page_text = extractedPageText
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'doc_id': repr(self.doc_id), f'mime_type': repr(self.mime_type), f'page_count': repr(self.page_count), f'total_page_count': repr(self.total_page_count), f'extracted_text': repr(
-            self.extracted_text), f'embedded_text': repr(self.embedded_text), f'pages': repr(self.pages), f'tokens': repr(self.tokens), f'metadata': repr(self.metadata), f'page_markdown': repr(self.page_markdown)}
+        repr_dict = {f'doc_id': repr(self.doc_id), f'mime_type': repr(self.mime_type), f'page_count': repr(self.page_count), f'total_page_count': repr(self.total_page_count), f'extracted_text': repr(self.extracted_text), f'embedded_text': repr(
+            self.embedded_text), f'pages': repr(self.pages), f'tokens': repr(self.tokens), f'metadata': repr(self.metadata), f'page_markdown': repr(self.page_markdown), f'extracted_page_text': repr(self.extracted_page_text)}
         class_name = "DocumentData"
         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])
@@ -49,5 +51,5 @@ class DocumentData(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'doc_id': self.doc_id, 'mime_type': self.mime_type, 'page_count': self.page_count, 'total_page_count': self.total_page_count, 'extracted_text': self.extracted_text,
-                'embedded_text': self.embedded_text, 'pages': self.pages, 'tokens': self.tokens, 'metadata': self.metadata, 'page_markdown': self.page_markdown}
+                'embedded_text': self.embedded_text, 'pages': self.pages, 'tokens': self.tokens, 'metadata': self.metadata, 'page_markdown': self.page_markdown, 'extracted_page_text': self.extracted_page_text}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}