abacusai 1.0.2__tar.gz → 1.0.5__tar.gz

{abacusai-1.0.2/abacusai.egg-info → abacusai-1.0.5}/PKG-INFO

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

abacusai-1.0.5/abacusai/__init__.py

@@ -0,0 +1,7 @@
+from .api_class import *
+from .client import AgentResponse, ApiClient, ApiException, ClientOptions, ReadOnlyClient, _request_context
+from .prediction_client import PredictionClient
+from .streaming_client import StreamingClient
+
+
+__version__ = "1.0.5"

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/agent.py

@@ -19,11 +19,12 @@ class Agent(AbstractApiClass):
             agentConfig (dict): The config options used to create this agent.
             memory (int): Memory in GB specified for the deployment resources for the agent.
             trainingRequired (bool): Whether training is required to deploy the latest agent code.
+            agentExecutionConfig (dict): The config for arguments used to execute the agent.
             latestAgentVersion (AgentVersion): The latest agent version.
             codeSource (CodeSource): If a python model, information on the source code
     """
 
-    def __init__(self, client, name=None, agentId=None, createdAt=None, projectId=None, notebookId=None, predictFunctionName=None, sourceCode=None, agentConfig=None, memory=None, trainingRequired=None, codeSource={}, latestAgentVersion={}):
+    def __init__(self, client, name=None, agentId=None, createdAt=None, projectId=None, notebookId=None, predictFunctionName=None, sourceCode=None, agentConfig=None, memory=None, trainingRequired=None, agentExecutionConfig=None, codeSource={}, latestAgentVersion={}):
         super().__init__(client, agentId)
         self.name = name
         self.agent_id = agentId
@@ -35,13 +36,14 @@ class Agent(AbstractApiClass):
         self.agent_config = agentConfig
         self.memory = memory
         self.training_required = trainingRequired
+        self.agent_execution_config = agentExecutionConfig
         self.code_source = client._build_class(CodeSource, codeSource)
         self.latest_agent_version = client._build_class(
             AgentVersion, latestAgentVersion)
 
     def __repr__(self):
         repr_dict = {f'name': repr(self.name), f'agent_id': repr(self.agent_id), f'created_at': repr(self.created_at), f'project_id': repr(self.project_id), f'notebook_id': repr(self.notebook_id), f'predict_function_name': repr(self.predict_function_name), f'source_code': repr(
-            self.source_code), f'agent_config': repr(self.agent_config), f'memory': repr(self.memory), f'training_required': repr(self.training_required), f'code_source': repr(self.code_source), f'latest_agent_version': repr(self.latest_agent_version)}
+            self.source_code), f'agent_config': repr(self.agent_config), f'memory': repr(self.memory), f'training_required': repr(self.training_required), f'agent_execution_config': repr(self.agent_execution_config), f'code_source': repr(self.code_source), f'latest_agent_version': repr(self.latest_agent_version)}
         class_name = "Agent"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -54,8 +56,8 @@ class Agent(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'name': self.name, 'agent_id': self.agent_id, 'created_at': self.created_at, 'project_id': self.project_id, 'notebook_id': self.notebook_id, 'predict_function_name': self.predict_function_name, 'source_code': self.source_code,
-                'agent_config': self.agent_config, 'memory': self.memory, 'training_required': self.training_required, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version)}
+        resp = {'name': self.name, 'agent_id': self.agent_id, 'created_at': self.created_at, 'project_id': self.project_id, 'notebook_id': self.notebook_id, 'predict_function_name': self.predict_function_name, 'source_code': self.source_code, 'agent_config': self.agent_config,
+                'memory': self.memory, 'training_required': self.training_required, 'agent_execution_config': self.agent_execution_config, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version)}
         return {key: value for key, value in resp.items() if value is not None}
 
     def refresh(self):

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/agent_version.py

@@ -17,10 +17,11 @@ class AgentVersion(AbstractApiClass):
             pendingDeploymentIds (list): List of deployment IDs where deployment is pending.
             failedDeploymentIds (list): List of failed deployment IDs.
             error (str): Relevant error if the status is FAILED.
+            agentExecutionConfig (dict): The config for arguments used to execute the agent.
             codeSource (CodeSource): If a python model, information on where the source code is located.
     """
 
-    def __init__(self, client, agentVersion=None, status=None, agentId=None, agentConfig=None, publishingStartedAt=None, publishingCompletedAt=None, pendingDeploymentIds=None, failedDeploymentIds=None, error=None, codeSource={}):
+    def __init__(self, client, agentVersion=None, status=None, agentId=None, agentConfig=None, publishingStartedAt=None, publishingCompletedAt=None, pendingDeploymentIds=None, failedDeploymentIds=None, error=None, agentExecutionConfig=None, codeSource={}):
         super().__init__(client, agentVersion)
         self.agent_version = agentVersion
         self.status = status
@@ -31,11 +32,12 @@ class AgentVersion(AbstractApiClass):
         self.pending_deployment_ids = pendingDeploymentIds
         self.failed_deployment_ids = failedDeploymentIds
         self.error = error
+        self.agent_execution_config = agentExecutionConfig
         self.code_source = client._build_class(CodeSource, codeSource)
 
     def __repr__(self):
         repr_dict = {f'agent_version': repr(self.agent_version), f'status': repr(self.status), f'agent_id': repr(self.agent_id), f'agent_config': repr(self.agent_config), f'publishing_started_at': repr(self.publishing_started_at), f'publishing_completed_at': repr(
-            self.publishing_completed_at), f'pending_deployment_ids': repr(self.pending_deployment_ids), f'failed_deployment_ids': repr(self.failed_deployment_ids), f'error': repr(self.error), f'code_source': repr(self.code_source)}
+            self.publishing_completed_at), f'pending_deployment_ids': repr(self.pending_deployment_ids), f'failed_deployment_ids': repr(self.failed_deployment_ids), f'error': repr(self.error), f'agent_execution_config': repr(self.agent_execution_config), f'code_source': repr(self.code_source)}
         class_name = "AgentVersion"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -49,7 +51,7 @@ class AgentVersion(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'agent_version': self.agent_version, 'status': self.status, 'agent_id': self.agent_id, 'agent_config': self.agent_config, 'publishing_started_at': self.publishing_started_at, 'publishing_completed_at': self.publishing_completed_at,
-                'pending_deployment_ids': self.pending_deployment_ids, 'failed_deployment_ids': self.failed_deployment_ids, 'error': self.error, 'code_source': self._get_attribute_as_dict(self.code_source)}
+                'pending_deployment_ids': self.pending_deployment_ids, 'failed_deployment_ids': self.failed_deployment_ids, 'error': self.error, 'agent_execution_config': self.agent_execution_config, 'code_source': self._get_attribute_as_dict(self.code_source)}
         return {key: value for key, value in resp.items() if value is not None}
 
     def refresh(self):

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/api_class/abstract.py

@@ -140,6 +140,10 @@ class ApiClass(ABC):
                 return builder.from_dict(input_dict)
             if not cls._upper_snake_case_keys:
                 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))
+                input_dict = {k: v for k, v in input_dict.items() if k in field_names}
         return cls(**input_dict)
 
 

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/api_class/enums.py

@@ -391,9 +391,9 @@ class LLMName(ApiEnum):
     LLAMA2_CHAT = 'LLAMA2_CHAT'
     PALM = 'PALM'
     PALM_TEXT = 'PALM_TEXT'
+    GEMINI_PRO = 'GEMINI_PRO'
     MIXTRAL_CHAT = 'MIXTRAL_CHAT'
-    MISTRAL = 'MISTRAL'
-    GEMINI = 'GEMINI'
+    MISTRAL_MEDIUM = 'MISTRAL_MEDIUM'
 
 
 class MonitorAlertType(ApiEnum):
@@ -411,6 +411,9 @@ class FeatureDriftType(ApiEnum):
     KS = 'ks'
     WS = 'ws'
     JS = 'js'
+    PSI = 'psi'
+    CHI_SQUARE = 'chi_square'
+    CSI = 'csi'
 
 
 class DataIntegrityViolationType(ApiEnum):

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/api_class/model.py

@@ -443,6 +443,8 @@ class ChatLLMTrainingConfig(TrainingConfig):
         behavior_instructions (str): Customize the overall role instructions for the LLM.
         response_instructions (str): Customize instructions for what the LLM responses should look like.
         max_search_results (int): Maximum number of search results in the retrieval augmentation step. If we know that the questions are likely to have snippets which are easily matched in the documents, then a lower number will help with accuracy.
+        data_feature_group_ids: (List[str]): List of feature group ids to use to possibly query for the chatllm.
+        data_prompt_context (str): Prompt context for the data feature group ids.
     """
     document_retrievers: List[str] = None
     num_completion_tokens: int = None
@@ -452,6 +454,8 @@ class ChatLLMTrainingConfig(TrainingConfig):
     behavior_instructions: str = None
     response_instructions: str = None
     max_search_results: int = None
+    data_feature_group_ids: List[str] = None
+    data_prompt_context: str = None
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.CHAT_LLM

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/client.py

@@ -168,6 +168,23 @@ DEFAULT_SERVER = 'https://api.abacus.ai'
 _request_context = threading.local()
 
 
+def _is_json_serializable(object: any):
+    """
+    Tests if an object is JSON serializable.
+
+    Args:
+        object (any): The object to test.
+
+    Returns:
+        bool: True if the object is JSON serializable, False otherwise.
+    """
+    try:
+        json.dumps(object)
+        return True
+    except TypeError:
+        return False
+
+
 def _requests_retry_session(retries=5, backoff_factor=0.1, status_forcelist=(502, 503, 504), session=None, retry_500: bool = False):
     session = session or requests.Session()
     if retry_500:
@@ -208,6 +225,29 @@ def _discover_service_url(service_discovery_url, client_version, deployment_id,
 _cached_endpoints = {}
 
 
+class Blob:
+
+    def __init__(self, contents: bytes, mime_type: str, filename: str = None):
+        self.filename = filename
+        self.contents = contents
+        self.mime_type = mime_type
+
+
+class AgentResponse:
+    """
+    Response Object for agent to support attachments
+    """
+
+    def __init__(self, *args):
+        self.data_list = []
+        for arg in args:
+            if isinstance(arg, Blob) or _is_json_serializable(arg):
+                self.data_list.append(arg)
+            else:
+                raise Exception(
+                    'AgentResponse can only contain Blob or json serializable objects')
+
+
 class ClientOptions:
     """
     Options for configuring the ApiClient
@@ -521,7 +561,7 @@ 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.0.2'
+    client_version = '1.0.5'
 
     def __init__(self, api_key: str = None, server: str = None, client_options: ClientOptions = None, skip_version_check: bool = False):
         self.api_key = api_key
@@ -736,11 +776,11 @@ class BaseApiClient:
                 val, dict)) else val for key, val in query_params.items()} if query_params else query_params
             return _session.get(url, params=cleaned_params, headers=headers, stream=stream)
         elif method == 'POST':
-            return _session.post(url, params=query_params, json=body, headers=headers, files=files, timeout=timeout or 200)
+            return _session.post(url, params=query_params, json=body, headers=headers, files=files, timeout=timeout or 600)
         elif method == 'PUT':
-            return _session.put(url, params=query_params, data=body, headers=headers, files=files, timeout=timeout or 200)
+            return _session.put(url, params=query_params, data=body, headers=headers, files=files, timeout=timeout or 600)
         elif method == 'PATCH':
-            return _session.patch(url, params=query_params, json=body, headers=headers, files=files, timeout=timeout or 200)
+            return _session.patch(url, params=query_params, json=body, headers=headers, files=files, timeout=timeout or 600)
         elif method == 'DELETE':
             return _session.delete(url, params=query_params, data=body, headers=headers)
         else:
@@ -4020,7 +4060,7 @@ class ApiClient(ReadOnlyClient):
             table_name (str): The unique name to be given to the feature group. Can be up to 120 characters long and can only contain alphanumeric characters and underscores.
             function_source_code (str): Contents of a valid source code file in a supported Feature Group specification language (currently only Python). The source code should contain a function called function_name. A list of allowed import and system libraries for each language is specified in the user functions documentation section.
             function_name (str): Name of the function found in the source code that will be executed (on the optional inputs) to materialize this feature group.
-            input_feature_groups (list): List of feature groups that are supplied to the function as parameters. Each of the parameters are materialized Dataframes (same type as the functions return value).
+            input_feature_groups (list): List of feature group names that are supplied to the function as parameters. Each of the parameters are materialized Dataframes (same type as the functions return value).
             description (str): The description for this feature group.
             cpu_size (str): Size of the CPU for the feature group function.
             memory (int): Memory (in GB) for the feature group function.
@@ -6376,17 +6416,20 @@ Creates a new feature group defined as the union of other feature group versions
             deployment_id, deployment_token)
         return self._call_api('describeImage', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id, 'categories': categories, 'topN': top_n}, files={'image': image}, server_override=prediction_url)
 
-    def get_text_from_document(self, deployment_token: str, deployment_id: str, document: io.TextIOBase = None, return_detected_images: bool = False) -> Dict:
+    def get_text_from_document(self, deployment_token: str, deployment_id: str, document: io.TextIOBase = None, adjust_doc_orientation: bool = False, return_detected_images: bool = False, save_predicted_pdf: bool = False, save_extracted_features: bool = False) -> Dict:
         """Generate text from a document
 
         Args:
             deployment_token (str): Authentication token to access created deployments. This token is only authorized to predict on deployments in the current project, and can be safely embedded in an application or website.
             deployment_id (str): Unique identifier of a deployment created under the project.
             document (io.TextIOBase): Input document which can be an image, pdf, or word document (Some formats might not be supported yet)
-            return_detected_images (bool): whether the detected images should be saved in docstore or not (if true, adds a docstore id to the response (may not be available for some algorithms))"""
+            adjust_doc_orientation (bool): (Optional) whether to detect the document page orientation and rotate it if needed.
+            return_detected_images (bool): whether the detected images should be saved in docstore or not (if true, adds a docstore id to the response (may not be available for some algorithms))
+            save_predicted_pdf (bool): (Optional) If True, will save the predicted pdf bytes so that they can be fetched using the prediction docId. Default is False.
+            save_extracted_features (bool): (Optional) If True, will save extracted features (i.e. page tokens) so that they can be fetched using the prediction docId. Default is False."""
         prediction_url = self._get_prediction_endpoint(
             deployment_id, deployment_token)
-        return self._call_api('getTextFromDocument', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id, 'returnDetectedImages': return_detected_images}, files={'document': document}, server_override=prediction_url)
+        return self._call_api('getTextFromDocument', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id, 'adjustDocOrientation': adjust_doc_orientation, 'returnDetectedImages': return_detected_images, 'savePredictedPdf': save_predicted_pdf, 'saveExtractedFeatures': save_extracted_features}, files={'document': document}, server_override=prediction_url)
 
     def transcribe_audio(self, deployment_token: str, deployment_id: str, audio: io.TextIOBase) -> Dict:
         """Transcribe the audio
@@ -7462,7 +7505,7 @@ Creates a new feature group defined as the union of other feature group versions
             user_message_indices (list): Optional list of user message indices to clear. The associated bot response will also be cleared. If not provided, all messages will be cleared."""
         return self._proxy_request('clearDeploymentConversation', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'deploymentConversationId': deployment_conversation_id, 'externalSessionId': external_session_id, 'userMessageIndices': user_message_indices}, is_sync=True)
 
-    def set_deployment_conversation_feedback(self, deployment_conversation_id: str, message_index: int, is_useful: bool = None, is_not_useful: bool = None, feedback: str = None, deployment_id: str = None, deployment_token: str = None):
+    def set_deployment_conversation_feedback(self, deployment_conversation_id: str, message_index: int, is_useful: bool = None, is_not_useful: bool = None, feedback: str = None, feedback_type: str = None, deployment_id: str = None, deployment_token: str = None):
         """Sets a deployment conversation message as useful or not useful
 
         Args:
@@ -7471,9 +7514,10 @@ Creates a new feature group defined as the union of other feature group versions
             is_useful (bool): If the message is useful. If true, the message is useful. If false, clear the useful flag.
             is_not_useful (bool): If the message is not useful. If true, the message is not useful. If set to false, clear the useful flag.
             feedback (str): Optional feedback on why the message is useful or not useful
+            feedback_type (str): Optional feedback type
             deployment_id (str): The deployment this conversation belongs to. This is required if not logged in.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in."""
-        return self._call_api('setDeploymentConversationFeedback', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'deploymentConversationId': deployment_conversation_id, 'messageIndex': message_index, 'isUseful': is_useful, 'isNotUseful': is_not_useful, 'feedback': feedback})
+        return self._call_api('setDeploymentConversationFeedback', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'deploymentConversationId': deployment_conversation_id, 'messageIndex': message_index, 'isUseful': is_useful, 'isNotUseful': is_not_useful, 'feedback': feedback, 'feedbackType': feedback_type})
 
     def rename_deployment_conversation(self, deployment_conversation_id: str, name: str, deployment_id: str = None, deployment_token: str = None):
         """Rename a Deployment Conversation.

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/dataset.py

@@ -1,6 +1,6 @@
 from typing import Union
 
-from .api_class import DatasetConfig, ParsingConfig
+from .api_class import DatasetConfig, DocumentProcessingConfig, ParsingConfig
 from .dataset_column import DatasetColumn
 from .dataset_version import DatasetVersion
 from .refresh_schedule import RefreshSchedule
@@ -36,7 +36,7 @@ class Dataset(AbstractApiClass):
             refreshSchedules (RefreshSchedule): List of schedules that determines when the next version of the dataset will be created.
     """
 
-    def __init__(self, client, datasetId=None, sourceType=None, dataSource=None, createdAt=None, ignoreBefore=None, ephemeral=None, lookbackDays=None, databaseConnectorId=None, databaseConnectorConfig=None, connectorType=None, featureGroupTableName=None, applicationConnectorId=None, applicationConnectorConfig=None, incremental=None, isDocumentset=None, extractBoundingBoxes=None, mergeFileSchemas=None, referenceOnlyDocumentset=None, schema={}, refreshSchedules={}, latestDatasetVersion={}, parsingConfig={}):
+    def __init__(self, client, datasetId=None, sourceType=None, dataSource=None, createdAt=None, ignoreBefore=None, ephemeral=None, lookbackDays=None, databaseConnectorId=None, databaseConnectorConfig=None, connectorType=None, featureGroupTableName=None, applicationConnectorId=None, applicationConnectorConfig=None, incremental=None, isDocumentset=None, extractBoundingBoxes=None, mergeFileSchemas=None, referenceOnlyDocumentset=None, schema={}, refreshSchedules={}, latestDatasetVersion={}, parsingConfig={}, documentProcessingConfig={}):
         super().__init__(client, datasetId)
         self.dataset_id = datasetId
         self.source_type = sourceType
@@ -62,10 +62,12 @@ class Dataset(AbstractApiClass):
         self.latest_dataset_version = client._build_class(
             DatasetVersion, latestDatasetVersion)
         self.parsing_config = client._build_class(ParsingConfig, parsingConfig)
+        self.document_processing_config = client._build_class(
+            DocumentProcessingConfig, documentProcessingConfig)
 
     def __repr__(self):
-        repr_dict = {f'dataset_id': repr(self.dataset_id), f'source_type': repr(self.source_type), f'data_source': repr(self.data_source), f'created_at': repr(self.created_at), f'ignore_before': repr(self.ignore_before), f'ephemeral': repr(self.ephemeral), f'lookback_days': repr(self.lookback_days), f'database_connector_id': repr(self.database_connector_id), f'database_connector_config': repr(self.database_connector_config), f'connector_type': repr(self.connector_type), f'feature_group_table_name': repr(self.feature_group_table_name), f'application_connector_id': repr(
-            self.application_connector_id), f'application_connector_config': repr(self.application_connector_config), f'incremental': repr(self.incremental), f'is_documentset': repr(self.is_documentset), f'extract_bounding_boxes': repr(self.extract_bounding_boxes), f'merge_file_schemas': repr(self.merge_file_schemas), f'reference_only_documentset': repr(self.reference_only_documentset), f'schema': repr(self.schema), f'refresh_schedules': repr(self.refresh_schedules), f'latest_dataset_version': repr(self.latest_dataset_version), f'parsing_config': repr(self.parsing_config)}
+        repr_dict = {f'dataset_id': repr(self.dataset_id), f'source_type': repr(self.source_type), f'data_source': repr(self.data_source), f'created_at': repr(self.created_at), f'ignore_before': repr(self.ignore_before), f'ephemeral': repr(self.ephemeral), f'lookback_days': repr(self.lookback_days), f'database_connector_id': repr(self.database_connector_id), f'database_connector_config': repr(self.database_connector_config), f'connector_type': repr(self.connector_type), f'feature_group_table_name': repr(self.feature_group_table_name), f'application_connector_id': repr(self.application_connector_id), f'application_connector_config': repr(
+            self.application_connector_config), f'incremental': repr(self.incremental), f'is_documentset': repr(self.is_documentset), f'extract_bounding_boxes': repr(self.extract_bounding_boxes), f'merge_file_schemas': repr(self.merge_file_schemas), f'reference_only_documentset': repr(self.reference_only_documentset), f'schema': repr(self.schema), f'refresh_schedules': repr(self.refresh_schedules), f'latest_dataset_version': repr(self.latest_dataset_version), f'parsing_config': repr(self.parsing_config), f'document_processing_config': repr(self.document_processing_config)}
         class_name = "Dataset"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -78,8 +80,8 @@ class Dataset(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'dataset_id': self.dataset_id, 'source_type': self.source_type, 'data_source': self.data_source, 'created_at': self.created_at, 'ignore_before': self.ignore_before, 'ephemeral': self.ephemeral, 'lookback_days': self.lookback_days, 'database_connector_id': self.database_connector_id, 'database_connector_config': self.database_connector_config, 'connector_type': self.connector_type, 'feature_group_table_name': self.feature_group_table_name, 'application_connector_id': self.application_connector_id, 'application_connector_config':
-                self.application_connector_config, 'incremental': self.incremental, 'is_documentset': self.is_documentset, 'extract_bounding_boxes': self.extract_bounding_boxes, 'merge_file_schemas': self.merge_file_schemas, 'reference_only_documentset': self.reference_only_documentset, 'schema': self._get_attribute_as_dict(self.schema), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules), 'latest_dataset_version': self._get_attribute_as_dict(self.latest_dataset_version), 'parsing_config': self._get_attribute_as_dict(self.parsing_config)}
+        resp = {'dataset_id': self.dataset_id, 'source_type': self.source_type, 'data_source': self.data_source, 'created_at': self.created_at, 'ignore_before': self.ignore_before, 'ephemeral': self.ephemeral, 'lookback_days': self.lookback_days, 'database_connector_id': self.database_connector_id, 'database_connector_config': self.database_connector_config, 'connector_type': self.connector_type, 'feature_group_table_name': self.feature_group_table_name, 'application_connector_id': self.application_connector_id, 'application_connector_config': self.application_connector_config,
+                'incremental': self.incremental, 'is_documentset': self.is_documentset, 'extract_bounding_boxes': self.extract_bounding_boxes, 'merge_file_schemas': self.merge_file_schemas, 'reference_only_documentset': self.reference_only_documentset, 'schema': self._get_attribute_as_dict(self.schema), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules), 'latest_dataset_version': self._get_attribute_as_dict(self.latest_dataset_version), 'parsing_config': self._get_attribute_as_dict(self.parsing_config), 'document_processing_config': self._get_attribute_as_dict(self.document_processing_config)}
         return {key: value for key, value in resp.items() if value is not None}
 
     def create_version_from_file_connector(self, location: str = None, file_format: str = None, csv_delimiter: str = None, merge_file_schemas: bool = None, parsing_config: Union[dict, ParsingConfig] = None):

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/deployment_conversation.py

@@ -83,7 +83,7 @@ class DeploymentConversation(AbstractApiClass):
         """
         return self.client.clear_deployment_conversation(self.deployment_conversation_id, external_session_id, deployment_id, deployment_token, user_message_indices)
 
-    def set_feedback(self, message_index: int, is_useful: bool = None, is_not_useful: bool = None, feedback: str = None, deployment_id: str = None, deployment_token: str = None):
+    def set_feedback(self, message_index: int, is_useful: bool = None, is_not_useful: bool = None, feedback: str = None, feedback_type: str = None, deployment_id: str = None, deployment_token: str = None):
         """
         Sets a deployment conversation message as useful or not useful
 
@@ -92,10 +92,11 @@ class DeploymentConversation(AbstractApiClass):
             is_useful (bool): If the message is useful. If true, the message is useful. If false, clear the useful flag.
             is_not_useful (bool): If the message is not useful. If true, the message is not useful. If set to false, clear the useful flag.
             feedback (str): Optional feedback on why the message is useful or not useful
+            feedback_type (str): Optional feedback type
             deployment_id (str): The deployment this conversation belongs to. This is required if not logged in.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in.
         """
-        return self.client.set_deployment_conversation_feedback(self.deployment_conversation_id, message_index, is_useful, is_not_useful, feedback, deployment_id, deployment_token)
+        return self.client.set_deployment_conversation_feedback(self.deployment_conversation_id, message_index, is_useful, is_not_useful, feedback, feedback_type, deployment_id, deployment_token)
 
     def rename(self, name: str, deployment_id: str = None, deployment_token: str = None):
         """

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/deployment_conversation_event.py

@@ -16,10 +16,12 @@ class DeploymentConversationEvent(AbstractApiClass):
             searchResults (dict): The search results for the message.
             isUseful (bool): Whether this message was marked as useful or not
             feedback (str): The feedback provided for the message
+            feedbackType (str): The type of feedback provided for the message
             docInfos (list): A list of information on the documents associated with the message
+            keywordArguments (dict): User message only. A dictionary of keyword arguments used to generate response.
     """
 
-    def __init__(self, client, role=None, text=None, timestamp=None, messageIndex=None, regenerateAttempt=None, modelVersion=None, searchResults=None, isUseful=None, feedback=None, docInfos=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):
         super().__init__(client, None)
         self.role = role
         self.text = text
@@ -30,11 +32,13 @@ class DeploymentConversationEvent(AbstractApiClass):
         self.search_results = searchResults
         self.is_useful = isUseful
         self.feedback = feedback
+        self.feedback_type = feedbackType
         self.doc_infos = docInfos
+        self.keyword_arguments = keywordArguments
 
     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'doc_infos': repr(self.doc_infos)}
+        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)}
         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])
@@ -47,6 +51,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, 'doc_infos': self.doc_infos}
+        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}
         return {key: value for key, value in resp.items() if value is not None}

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/document_retriever.py

@@ -144,6 +144,11 @@ class DocumentRetriever(AbstractApiClass):
         Args:
             timeout (int, optional): The waiting time given to the call to finish, if it doesn't finish by the allocated time, the call is said to be timed out. Default value given is 3600 seconds.
         """
+        # For the first time this is called, e.g. called after createDocumentRetriever, it needs to do indexing.
+        # In this case, get_status will not return STOPPED but deployment could be in STOPPED state, due to
+        # we set deployment to be off by default for some cases.
+        # So wait for indexing is done and then call restart.
+        self.client._poll(self, {'PENDING', 'INDEXING'}, timeout=timeout / 2)
         if self.get_status() == 'STOPPED':
             self.client.restart_document_retriever(self.document_retriever_id)
         version = self.describe().latest_document_retriever_version

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/embedding_feature_drift_distribution.py

@@ -11,20 +11,26 @@ class EmbeddingFeatureDriftDistribution(AbstractApiClass):
             jsDistance (list): Histogram data of JS divergence between the training distribution and the range of values in the specified window.
             wsDistance (list): Histogram data of Wasserstein distance between the training distribution and the range of values in the specified window.
             ksStatistic (list): Histogram data of Kolmogorov-Smirnov statistic computed between the training distribution and the range of values in the specified window.
+            psi (list): Histogram data of Population stability index computed between the training distribution and the range of values in the specified window.
+            csi (list): Histogram data of Characteristic Stability Index computed between the training distribution and the range of values in the specified window.
+            chiSquare (list): Histogram data of Chi-square statistic computed between the training distribution and the range of values in the specified window.
             averageDrift (DriftTypesValue): Average drift embedding for each type of drift
     """
 
-    def __init__(self, client, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None, averageDrift={}):
+    def __init__(self, client, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None, psi=None, csi=None, chiSquare=None, averageDrift={}):
         super().__init__(client, None)
         self.distance = distance
         self.js_distance = jsDistance
         self.ws_distance = wsDistance
         self.ks_statistic = ksStatistic
+        self.psi = psi
+        self.csi = csi
+        self.chi_square = chiSquare
         self.average_drift = client._build_class(DriftTypesValue, averageDrift)
 
     def __repr__(self):
-        repr_dict = {f'distance': repr(self.distance), f'js_distance': repr(self.js_distance), f'ws_distance': repr(
-            self.ws_distance), f'ks_statistic': repr(self.ks_statistic), f'average_drift': repr(self.average_drift)}
+        repr_dict = {f'distance': repr(self.distance), f'js_distance': repr(self.js_distance), f'ws_distance': repr(self.ws_distance), f'ks_statistic': repr(
+            self.ks_statistic), f'psi': repr(self.psi), f'csi': repr(self.csi), f'chi_square': repr(self.chi_square), f'average_drift': repr(self.average_drift)}
         class_name = "EmbeddingFeatureDriftDistribution"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -37,6 +43,6 @@ class EmbeddingFeatureDriftDistribution(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'distance': self.distance, 'js_distance': self.js_distance, 'ws_distance': self.ws_distance,
-                'ks_statistic': self.ks_statistic, 'average_drift': self._get_attribute_as_dict(self.average_drift)}
+        resp = {'distance': self.distance, 'js_distance': self.js_distance, 'ws_distance': self.ws_distance, 'ks_statistic': self.ks_statistic,
+                'psi': self.psi, 'csi': self.csi, 'chi_square': self.chi_square, 'average_drift': self._get_attribute_as_dict(self.average_drift)}
         return {key: value for key, value in resp.items() if value is not None}

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/feature_drift_record.py

@@ -12,19 +12,25 @@ class FeatureDriftRecord(AbstractApiClass):
             jsDistance (float): JS divergence between the training distribution and the range of values in the specified window.
             wsDistance (float): Wasserstein distance between the training distribution and the range of values in the specified window.
             ksStatistic (float): Kolmogorov-Smirnov statistic computed between the training distribution and the range of values in the specified window.
+            psi (float): Population stability index computed between the training distribution and the range of values in the specified window.
+            csi (float): Characteristic Stability Index computed between the training distribution and the range of values in the specified window.
+            chiSquare (float): Chi-square statistic computed between the training distribution and the range of values in the specified window.
     """
 
-    def __init__(self, client, name=None, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None):
+    def __init__(self, client, name=None, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None, psi=None, csi=None, chiSquare=None):
         super().__init__(client, None)
         self.name = name
         self.distance = distance
         self.js_distance = jsDistance
         self.ws_distance = wsDistance
         self.ks_statistic = ksStatistic
+        self.psi = psi
+        self.csi = csi
+        self.chi_square = chiSquare
 
     def __repr__(self):
-        repr_dict = {f'name': repr(self.name), f'distance': repr(self.distance), f'js_distance': repr(
-            self.js_distance), f'ws_distance': repr(self.ws_distance), f'ks_statistic': repr(self.ks_statistic)}
+        repr_dict = {f'name': repr(self.name), f'distance': repr(self.distance), f'js_distance': repr(self.js_distance), f'ws_distance': repr(
+            self.ws_distance), f'ks_statistic': repr(self.ks_statistic), f'psi': repr(self.psi), f'csi': repr(self.csi), f'chi_square': repr(self.chi_square)}
         class_name = "FeatureDriftRecord"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -37,6 +43,6 @@ class FeatureDriftRecord(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'name': self.name, 'distance': self.distance, 'js_distance': self.js_distance,
-                'ws_distance': self.ws_distance, 'ks_statistic': self.ks_statistic}
+        resp = {'name': self.name, 'distance': self.distance, 'js_distance': self.js_distance, 'ws_distance': self.ws_distance,
+                'ks_statistic': self.ks_statistic, 'psi': self.psi, 'csi': self.csi, 'chi_square': self.chi_square}
         return {key: value for key, value in resp.items() if value is not None}

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/feature_drift_summary.py

@@ -21,13 +21,16 @@ class FeatureDriftSummary(AbstractApiClass):
             targetColumn (str): Target column name.
             dataIntegrityTimeseries (dict): Frequency vs Data Integrity Violation Charts.
             nestedSummary (list[dict]): Summary of model monitoring statistics for nested features.
+            psi (float): Population stability index computed between the training distribution and the range of values in the specified window.
+            csi (float): Characteristic Stability Index computed between the training distribution and the range of values in the specified window.
+            chiSquare (float): Chi-square statistic computed between the training distribution and the range of values in the specified window.
             nullViolations (NullViolation): A list of dicts of feature names and a description of corresponding null violations.
             typeViolations (TypeViolation): A list of dicts of feature names and corresponding type mismatches.
             rangeViolations (RangeViolation): A list of dicts of numerical feature names and corresponding prediction range discrepancies.
             catViolations (CategoricalRangeViolation): A list of dicts of categorical feature names and corresponding prediction range discrepancies.
     """
 
-    def __init__(self, client, featureIndex=None, name=None, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None, predictionDrift=None, targetColumn=None, dataIntegrityTimeseries=None, nestedSummary=None, nullViolations={}, typeViolations={}, rangeViolations={}, catViolations={}):
+    def __init__(self, client, featureIndex=None, name=None, distance=None, jsDistance=None, wsDistance=None, ksStatistic=None, predictionDrift=None, targetColumn=None, dataIntegrityTimeseries=None, nestedSummary=None, psi=None, csi=None, chiSquare=None, nullViolations={}, typeViolations={}, rangeViolations={}, catViolations={}):
         super().__init__(client, None)
         self.feature_index = featureIndex
         self.name = name
@@ -39,6 +42,9 @@ class FeatureDriftSummary(AbstractApiClass):
         self.target_column = targetColumn
         self.data_integrity_timeseries = dataIntegrityTimeseries
         self.nested_summary = nestedSummary
+        self.psi = psi
+        self.csi = csi
+        self.chi_square = chiSquare
         self.null_violations = client._build_class(
             NullViolation, nullViolations)
         self.type_violations = client._build_class(
@@ -49,8 +55,8 @@ class FeatureDriftSummary(AbstractApiClass):
             CategoricalRangeViolation, catViolations)
 
     def __repr__(self):
-        repr_dict = {f'feature_index': repr(self.feature_index), f'name': repr(self.name), f'distance': repr(self.distance), f'js_distance': repr(self.js_distance), f'ws_distance': repr(self.ws_distance), f'ks_statistic': repr(self.ks_statistic), f'prediction_drift': repr(self.prediction_drift), f'target_column': repr(
-            self.target_column), f'data_integrity_timeseries': repr(self.data_integrity_timeseries), f'nested_summary': repr(self.nested_summary), f'null_violations': repr(self.null_violations), f'type_violations': repr(self.type_violations), f'range_violations': repr(self.range_violations), f'cat_violations': repr(self.cat_violations)}
+        repr_dict = {f'feature_index': repr(self.feature_index), f'name': repr(self.name), f'distance': repr(self.distance), f'js_distance': repr(self.js_distance), f'ws_distance': repr(self.ws_distance), f'ks_statistic': repr(self.ks_statistic), f'prediction_drift': repr(self.prediction_drift), f'target_column': repr(self.target_column), f'data_integrity_timeseries': repr(
+            self.data_integrity_timeseries), f'nested_summary': repr(self.nested_summary), f'psi': repr(self.psi), f'csi': repr(self.csi), f'chi_square': repr(self.chi_square), f'null_violations': repr(self.null_violations), f'type_violations': repr(self.type_violations), f'range_violations': repr(self.range_violations), f'cat_violations': repr(self.cat_violations)}
         class_name = "FeatureDriftSummary"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -63,6 +69,6 @@ class FeatureDriftSummary(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'feature_index': self.feature_index, 'name': self.name, 'distance': self.distance, 'js_distance': self.js_distance, 'ws_distance': self.ws_distance, 'ks_statistic': self.ks_statistic, 'prediction_drift': self.prediction_drift, 'target_column': self.target_column, 'data_integrity_timeseries': self.data_integrity_timeseries,
-                'nested_summary': self.nested_summary, 'null_violations': self._get_attribute_as_dict(self.null_violations), 'type_violations': self._get_attribute_as_dict(self.type_violations), 'range_violations': self._get_attribute_as_dict(self.range_violations), 'cat_violations': self._get_attribute_as_dict(self.cat_violations)}
+        resp = {'feature_index': self.feature_index, 'name': self.name, 'distance': self.distance, 'js_distance': self.js_distance, 'ws_distance': self.ws_distance, 'ks_statistic': self.ks_statistic, 'prediction_drift': self.prediction_drift, 'target_column': self.target_column, 'data_integrity_timeseries': self.data_integrity_timeseries, 'nested_summary': self.nested_summary,
+                'psi': self.psi, 'csi': self.csi, 'chi_square': self.chi_square, 'null_violations': self._get_attribute_as_dict(self.null_violations), 'type_violations': self._get_attribute_as_dict(self.type_violations), 'range_violations': self._get_attribute_as_dict(self.range_violations), 'cat_violations': self._get_attribute_as_dict(self.cat_violations)}
         return {key: value for key, value in resp.items() if value is not None}

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/feature_group.py

@@ -1228,7 +1228,7 @@ class FeatureGroup(AbstractApiClass):
 
         Args:
             doc_id_feature (str): The name of the feature / column containing the document ID.
-            document_feature (str): The name of the feature / column containing the page infos. This column will be replaced with the extracted document data.
+            document_feature (str): The name of the feature / column which either contains the document data itself or page infos with path to remotely stored documents. This column will be replaced with the extracted document data.
 
         Returns:
             DataFrame: A pandas dataframe containing the extracted document data.

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/feature_group_version.py

@@ -250,7 +250,7 @@ class FeatureGroupVersion(AbstractApiClass):
 
         Args:
             doc_id_feature (str): The name of the feature / column containing the document ID.
-            document_feature (str): The name of the feature / column containing the page infos. This column will be replaced with the extracted document data.
+            document_feature (str): The name of the feature / column which either contains the document data itself or page infos with path to remotely stored documents. This column will be replaced with the extracted document data.
             max_workers (int, optional): The number of threads.
 
         Returns:

{abacusai-1.0.2 → abacusai-1.0.5}/abacusai/forecasting_monitor_summary.py

@@ -22,8 +22,8 @@ class ForecastingMonitorSummary(AbstractApiClass):
             predictionsHistogram (ForecastingAnalysisGraphData): Data showing predictions histogram
             trainHistoryData (ForecastingAnalysisGraphData): Data showing length of history distribution
             predictHistoryData (ForecastingAnalysisGraphData): Data showing length of history distribution
-            targetDrift (FeatureDriftRecord): Data showing drift of the target for all drift types: distance (KL divergence), js_distance, ws_distance, ks_statistic
-            historyDrift (FeatureDriftRecord): Data showing drift of the history for all drift types: distance (KL divergence), js_distance, ws_distance, ks_statistic
+            targetDrift (FeatureDriftRecord): Data showing drift of the target for all drift types: distance (KL divergence), js_distance, ws_distance, ks_statistic, psi, csi, chi_square
+            historyDrift (FeatureDriftRecord): Data showing drift of the history for all drift types: distance (KL divergence), js_distance, ws_distance, ks_statistic, psi, csi, chi_square
     """
 
     def __init__(self, client, predictionTimestampCol=None, predictionTargetCol=None, trainingTimestampCol=None, trainingTargetCol=None, predictionItemId=None, trainingItemId=None, forecastFrequency=None, trainingTargetAcrossTime={}, predictionTargetAcrossTime={}, actualsHistogram={}, predictionsHistogram={}, trainHistoryData={}, predictHistoryData={}, targetDrift={}, historyDrift={}):