abacusai 0.79.0__tar.gz → 0.79.2__tar.gz

{abacusai-0.79.0/abacusai.egg-info → abacusai-0.79.2}/PKG-INFO

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

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/__init__.py

@@ -4,4 +4,4 @@ from .prediction_client import PredictionClient
 from .streaming_client import StreamingClient
 
 
-__version__ = "0.79.0"
+__version__ = "0.79.2"

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_class/__init__.py

@@ -1,3 +1,4 @@
+from .ai_agents import *
 from .batch_prediction import *
 from .blob_input import *
 from .dataset import *

abacusai-0.79.2/abacusai/api_class/ai_agents.py

@@ -0,0 +1,22 @@
+import dataclasses
+from typing import Union
+
+from . import enums
+from .abstract import ApiClass
+
+
+@dataclasses.dataclass
+class FieldDescriptor(ApiClass):
+    """
+    Configs for vector store indexing.
+
+    Args:
+        field (str): The field to be extracted. This will be used as the key in the response.
+        description (str): The description of this field. If not included, the response_field will be used.
+        example_extraction (Union[str, int, bool, float]): An example of this extracted field.
+        type (enums.FieldDescriptorType): The type of this field. If not provided, the default type is STRING.
+    """
+    field: str = dataclasses.field()
+    description: str = dataclasses.field(default=None)
+    example_extraction: Union[str, int, bool, float, list, dict] = dataclasses.field(default=None)
+    type: enums.FieldDescriptorType = dataclasses.field(default=enums.FieldDescriptorType.STRING)

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_class/dataset.py

@@ -19,3 +19,4 @@ class DocumentProcessingConfig(ApiClass):
     remove_watermarks: bool = None
     use_full_ocr: bool = None
     layout_analysis: bool = False
+    enhanced_layout_detection: bool = False

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_class/dataset_application_connector.py

@@ -39,6 +39,27 @@ class GoogleAnalyticsDatasetConfig(DatasetConfig):
         self.application_connector_type = enums.ApplicationConnectorType.GOOGLEANALYTICS
 
 
+@dataclasses.dataclass
+class GoogleDriveDatasetConfig(DatasetConfig):
+    """
+    Dataset config for Google Drive Application Connector
+    Args:
+        location (str): The regex location of the files to fetch
+        is_documentset (bool): Whether the dataset is a document set
+        csv_delimiter (str, optional): If the file format is CSV, use a specific csv delimiter
+        extract_bounding_boxes (bool, optional): Signifies whether to extract bounding boxes out of the documents. Only valid if is_documentset if True
+        merge_file_schemas (bool, optional): Signifies if the merge file schema policy is enabled. Not applicable if is_documentset is True
+    """
+    location: str = dataclasses.field(default=None)
+    is_documentset: bool = dataclasses.field(default=None)
+    csv_delimiter: str = dataclasses.field(default=None)
+    extract_bounding_boxes: bool = dataclasses.field(default=False)
+    merge_file_schemas: bool = dataclasses.field(default=False)
+
+    def __post_init__(self):
+        self.application_connector_type = enums.ApplicationConnectorType.GOOGLEDRIVE
+
+
 @dataclasses.dataclass
 class SharepointDatasetConfig(DatasetConfig):
     """
@@ -48,7 +69,7 @@ class SharepointDatasetConfig(DatasetConfig):
         is_documentset (bool): Whether the dataset is a document set
         csv_delimiter (str, optional): If the file format is CSV, use a specific csv delimiter
         extract_bounding_boxes (bool, optional): Signifies whether to extract bounding boxes out of the documents. Only valid if is_documentset if True
-        merge_file_schemas (bool, optional): Signifies if the merge file schema policy is enabled. If is_documentset is True, this is also set to True by default
+        merge_file_schemas (bool, optional): Signifies if the merge file schema policy is enabled. Not applicable if is_documentset is True
     """
     location: str = dataclasses.field(default=None)
     is_documentset: bool = dataclasses.field(default=None)
@@ -76,6 +97,7 @@ class _DatasetConfigFactory(_ApiClassFactory):
     config_class_map = {
         enums.ApplicationConnectorType.CONFLUENCE: ConfluenceDatasetConfig,
         enums.ApplicationConnectorType.GOOGLEANALYTICS: GoogleAnalyticsDatasetConfig,
+        enums.ApplicationConnectorType.GOOGLEDRIVE: GoogleDriveDatasetConfig,
         enums.ApplicationConnectorType.SHAREPOINT: SharepointDatasetConfig,
         enums.ApplicationConnectorType.ZENDESK: ZendeskDatasetConfig,
     }

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_class/enums.py

@@ -323,6 +323,7 @@ class ConnectorType(ApiEnum):
 
 class ApplicationConnectorType(ApiEnum):
     GOOGLEANALYTICS = 'GOOGLEANALYTICS'
+    GOOGLEDRIVE = 'GOOGLEDRIVE'
     GIT = 'GIT'
     CONFLUENCE = 'CONFLUENCE'
     ZENDESK = 'ZENDESK'
@@ -422,3 +423,18 @@ class PythonFunctionType(ApiEnum):
     FEATURE_GROUP = 'FEATURE_GROUP'
     PLOTLY_FIG = 'PLOTLY_FIG'
     STEP_FUNCTION = 'STEP_FUNCTION'
+
+
+class EvalArtifactType(ApiEnum):
+    FORECASTING_ACCURACY = 'bar_chart'
+    FORECASTING_VOLUME = 'bar_chart_volume'
+    FORECASTING_HISTORY_LENGTH_ACCURACY = 'bar_chart_accuracy_by_history'
+
+
+class FieldDescriptorType(ApiEnum):
+    STRING = 'STRING'
+    INTEGER = 'INTEGER'
+    FLOAT = 'FLOAT'
+    BOOLEAN = 'BOOLEAN'
+    DATETIME = 'DATETIME'
+    DATE = 'DATE'

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_class/model.py

@@ -57,11 +57,7 @@ class PersonalizationTrainingConfig(TrainingConfig):
         compute_session_metrics (bool): Evaluate models based on how well they are able to predict the next session of interactions.
         max_user_history_len_percentile (int): Filter out users with history length above this percentile.
         downsample_item_popularity_percentile (float): Downsample items more popular than this percentile.
-<<<<<<< HEAD
-        allow_duplicate_action_types (List[str]): event types which will not be deduplicated.
         use_user_id_feature (bool): Use user id as a feature in CTR models.
-=======
->>>>>>> e5f12c159c (add config options for session dedupe and recommendation exclusion)
     """
     # top-level params
     objective: enums.PersonalizationObjective = dataclasses.field(default=None)
@@ -382,6 +378,8 @@ class NamedEntityExtractionTrainingConfig(TrainingConfig):
         active_labels_column (str): Entities that have been marked in a particular text
         document_format (NLPDocumentFormat): Format of the input documents.
         include_longformer (bool): Whether to include the longformer model.
+        save_predicted_pdf (bool): Whether to save predicted PDF documents
+        enhanced_ocr (bool): Enhanced text extraction from predicted digital documents
     """
     objective: enums.NERObjective = dataclasses.field(default=None)
     sort_objective: enums.NERObjective = dataclasses.field(default=None)
@@ -396,6 +394,9 @@ class NamedEntityExtractionTrainingConfig(TrainingConfig):
     active_labels_column: str = dataclasses.field(default=None)
     document_format: enums.NLPDocumentFormat = dataclasses.field(default=None)
     include_longformer: bool = dataclasses.field(default=None)
+    # OCR
+    save_predicted_pdf: bool = True
+    enhanced_ocr: bool = False
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.NAMED_ENTITY_EXTRACTION

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/api_endpoint.py

@@ -10,17 +10,19 @@ class ApiEndpoint(AbstractApiClass):
             apiEndpoint (str): The URI that can be used to make API calls
             predictEndpoint (str): The URI that can be used to make predict calls against Deployments
             proxyEndpoint (str): The URI that can be used to make proxy server calls
+            llmEndpoint (str): The URI that can be used to make llm api calls
     """
 
-    def __init__(self, client, apiEndpoint=None, predictEndpoint=None, proxyEndpoint=None):
+    def __init__(self, client, apiEndpoint=None, predictEndpoint=None, proxyEndpoint=None, llmEndpoint=None):
         super().__init__(client, None)
         self.api_endpoint = apiEndpoint
         self.predict_endpoint = predictEndpoint
         self.proxy_endpoint = proxyEndpoint
+        self.llm_endpoint = llmEndpoint
 
     def __repr__(self):
         repr_dict = {f'api_endpoint': repr(self.api_endpoint), f'predict_endpoint': repr(
-            self.predict_endpoint), f'proxy_endpoint': repr(self.proxy_endpoint)}
+            self.predict_endpoint), f'proxy_endpoint': repr(self.proxy_endpoint), f'llm_endpoint': repr(self.llm_endpoint)}
         class_name = "ApiEndpoint"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -33,6 +35,6 @@ class ApiEndpoint(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'api_endpoint': self.api_endpoint, 'predict_endpoint':
-                self.predict_endpoint, 'proxy_endpoint': self.proxy_endpoint}
+        resp = {'api_endpoint': self.api_endpoint, 'predict_endpoint': self.predict_endpoint,
+                'proxy_endpoint': self.proxy_endpoint, 'llm_endpoint': self.llm_endpoint}
         return {key: value for key, value in resp.items() if value is not None}

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/chat_session.py

@@ -16,11 +16,12 @@ class ChatSession(AbstractApiClass):
             createdAt (str): The timestamp at which the chat session was created
             status (str): The status of the chat sessions
             aiBuildingInProgress (bool): Whether the AI building is in progress or not
+            notification (str): A warn/info message about the chat session. For example, a suggestion to create a new session if the current one is too old
             chatHistory (ChatMessage): The chat history for the conversation
             nextAiBuildingTask (AiBuildingTask): The next AI building task for the chat session
     """
 
-    def __init__(self, client, answer=None, chatSessionId=None, projectId=None, name=None, createdAt=None, status=None, aiBuildingInProgress=None, chatHistory={}, nextAiBuildingTask={}):
+    def __init__(self, client, answer=None, chatSessionId=None, projectId=None, name=None, createdAt=None, status=None, aiBuildingInProgress=None, notification=None, chatHistory={}, nextAiBuildingTask={}):
         super().__init__(client, chatSessionId)
         self.answer = answer
         self.chat_session_id = chatSessionId
@@ -29,13 +30,14 @@ class ChatSession(AbstractApiClass):
         self.created_at = createdAt
         self.status = status
         self.ai_building_in_progress = aiBuildingInProgress
+        self.notification = notification
         self.chat_history = client._build_class(ChatMessage, chatHistory)
         self.next_ai_building_task = client._build_class(
             AiBuildingTask, nextAiBuildingTask)
 
     def __repr__(self):
         repr_dict = {f'answer': repr(self.answer), f'chat_session_id': repr(self.chat_session_id), f'project_id': repr(self.project_id), f'name': repr(self.name), f'created_at': repr(self.created_at), f'status': repr(
-            self.status), f'ai_building_in_progress': repr(self.ai_building_in_progress), f'chat_history': repr(self.chat_history), f'next_ai_building_task': repr(self.next_ai_building_task)}
+            self.status), f'ai_building_in_progress': repr(self.ai_building_in_progress), f'notification': repr(self.notification), f'chat_history': repr(self.chat_history), f'next_ai_building_task': repr(self.next_ai_building_task)}
         class_name = "ChatSession"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None])
@@ -48,8 +50,8 @@ class ChatSession(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'answer': self.answer, 'chat_session_id': self.chat_session_id, 'project_id': self.project_id, 'name': self.name, 'created_at': self.created_at, 'status': self.status,
-                'ai_building_in_progress': self.ai_building_in_progress, 'chat_history': self._get_attribute_as_dict(self.chat_history), 'next_ai_building_task': self._get_attribute_as_dict(self.next_ai_building_task)}
+        resp = {'answer': self.answer, 'chat_session_id': self.chat_session_id, 'project_id': self.project_id, 'name': self.name, 'created_at': self.created_at, 'status': self.status, 'ai_building_in_progress':
+                self.ai_building_in_progress, 'notification': self.notification, 'chat_history': self._get_attribute_as_dict(self.chat_history), 'next_ai_building_task': self._get_attribute_as_dict(self.next_ai_building_task)}
         return {key: value for key, value in resp.items() if value is not None}
 
     def get(self):

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/client.py

@@ -31,9 +31,9 @@ from .annotations_status import AnnotationsStatus
 from .api_class import (
     AlertActionConfig, AlertConditionConfig, ApiClass, ApiEnum,
     BatchPredictionArgs, DatasetConfig, DocumentRetrieverConfig,
-    FeatureGroupExportConfig, ForecastingMonitorConfig, MergeConfig,
-    ParsingConfig, ProblemType, PythonFunctionType, SamplingConfig,
-    TrainingConfig
+    EvalArtifactType, FeatureGroupExportConfig, ForecastingMonitorConfig,
+    MergeConfig, ParsingConfig, ProblemType, PythonFunctionType,
+    SamplingConfig, TrainingConfig
 )
 from .api_client_utils import (
     INVALID_PANDAS_COLUMN_NAME_CHARACTERS, clean_column_name,
@@ -76,6 +76,7 @@ from .eda_forecasting_analysis import EdaForecastingAnalysis
 from .eda_version import EdaVersion
 from .execute_feature_group_operation import ExecuteFeatureGroupOperation
 from .external_application import ExternalApplication
+from .extracted_fields import ExtractedFields
 from .feature import Feature
 from .feature_distribution import FeatureDistribution
 from .feature_group import FeatureGroup
@@ -100,6 +101,7 @@ from .holdout_analysis import HoldoutAnalysis
 from .holdout_analysis_version import HoldoutAnalysisVersion
 from .inferred_feature_mappings import InferredFeatureMappings
 from .llm_execution_result import LlmExecutionResult
+from .llm_generated_code import LlmGeneratedCode
 from .llm_input import LlmInput
 from .llm_parameters import LlmParameters
 from .llm_response import LlmResponse
@@ -515,7 +517,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 = '0.79.0'
+    client_version = '0.79.2'
 
     def __init__(self, api_key: str = None, server: str = None, client_options: ClientOptions = None, skip_version_check: bool = False):
         self.api_key = api_key
@@ -2054,7 +2056,7 @@ class ReadOnlyClient(BaseApiClient):
 
         Returns:
             list[FeatureGroupRow]: A list of feature group rows."""
-        return self._call_api('getData', 'GET', query_params={'featureGroupId': feature_group_id, 'primaryKey': primary_key, 'numRows': num_rows}, parse_type=FeatureGroupRow)
+        return self._proxy_request('getData', 'GET', query_params={'featureGroupId': feature_group_id, 'primaryKey': primary_key, 'numRows': num_rows}, parse_type=FeatureGroupRow, is_sync=True)
 
     def list_pending_feature_group_documents(self, feature_group_id: str) -> List[FeatureGroupDocument]:
         """Lists all pending documents added to feature group.
@@ -2411,6 +2413,13 @@ class ReadOnlyClient(BaseApiClient):
             ExternalApplication: The External Application."""
         return self._call_api('describeExternalApplication', 'GET', query_params={'externalApplicationId': external_application_id}, parse_type=ExternalApplication)
 
+    def list_external_applications(self) -> List[ExternalApplication]:
+        """Lists External Applications in an organization.
+
+        Returns:
+            list[ExternalApplication]: List of External Applications."""
+        return self._call_api('listExternalApplications', 'GET', query_params={}, parse_type=ExternalApplication)
+
     def describe_agent(self, agent_id: str) -> Agent:
         """Retrieves a full description of the specified model.
 
@@ -3330,6 +3339,36 @@ class ApiClient(ReadOnlyClient):
         """
         _request_context.chat_history = chat_history
 
+    def get_agent_context_conversation_id(self):
+        """
+        Gets the deployment conversation ID from the current request context. Applicable within a AIAgent
+        execute function.
+
+        Returns:
+            str: The deployment conversation ID for the current request being processed by the Agent.
+        """
+        return get_object_from_context(self, _request_context, 'deployment_conversation_id', str)
+
+    def get_agent_context_external_session_id(self):
+        """
+        Gets the external session ID from the current request context if it has been set with the request.
+        Applicable within a AIAgent execute function.
+
+        Returns:
+            str: The external session ID for the current request being processed by the Agent.
+        """
+        return get_object_from_context(self, _request_context, 'external_session_id', str)
+
+    def get_agent_context_doc_ids(self):
+        """
+        Gets the document ID from the current request context if a document has been uploaded with the request. 
+        Applicable within a AIAgent execute function.
+
+        Returns:
+            List[str]: The document IDs the current request being processed by the Agent.
+        """
+        return get_object_from_context(self, _request_context, 'doc_ids', List[str])
+
     def clear_agent_context(self):
         """
         Clears the current request context.
@@ -3512,11 +3551,11 @@ class ApiClient(ReadOnlyClient):
         Returns:
             pandas.DataFrame: The result of the query.
         """
-        sql = self.generate_code_for_data_query_using_llm(
+        code = self.generate_code_for_data_query_using_llm(
             query=query, feature_group_ids=feature_group_ids, prompt_context=prompt_context, llm_name=llm_name, temperature=temperature)
         if preview:
-            return self._build_class(LlmExecutionResult, {'preview': {'sql': sql}})
-        execute_query = self.execute_async_feature_group_operation(sql)
+            return self._build_class(LlmExecutionResult, {'preview': {'sql': code.sql}})
+        execute_query = self.execute_async_feature_group_operation(code.sql)
         execute_query.wait_for_execution(timeout=timeout, delay=delay)
         return self._build_class(LlmExecutionResult, {'error': execute_query.error}) if execute_query.error else execute_query.load_as_pandas()
 
@@ -4970,10 +5009,7 @@ Creates a new feature group defined as the union of other feature group versions
         return self._call_api('createTrainTestDataSplitFeatureGroup', 'POST', query_params={}, body={'projectId': project_id, 'trainingConfig': training_config, 'featureGroupIds': feature_group_ids}, parse_type=FeatureGroup)
 
     def train_model(self, project_id: str, name: str = None, training_config: Union[dict, TrainingConfig] = None, feature_group_ids: list = None, refresh_schedule: str = None, custom_algorithms: list = None, custom_algorithms_only: bool = False, custom_algorithm_configs: dict = None, builtin_algorithms: list = None, cpu_size: str = None, memory: int = None, algorithm_training_configs: list = None) -> Model:
-        """Train a model for the specified project.
-
-        This method trains a model in the given project, using user-specified training configurations defined in the `getTrainingConfigOptions` method.
-
+        """Create a new model and start its training in the given project.
 
         Args:
             project_id (str): The unique ID associated with the project.
@@ -4984,7 +5020,7 @@ Creates a new feature group defined as the union of other feature group versions
             custom_algorithms (list): List of user-defined algorithms to train. If not set, the default enabled custom algorithms will be used.
             custom_algorithms_only (bool): Whether to only run custom algorithms.
             custom_algorithm_configs (dict): Configs for each user-defined algorithm; key is the algorithm name, value is the config serialized to JSON.
-            builtin_algorithms (list): List of IDs of the builtin algorithms provided by Abacus.AI to train. If not set, all applicable builtin algorithms will be used.
+            builtin_algorithms (list): List of algorithm names or algorithm IDs of the builtin algorithms provided by Abacus.AI to train. If not set, all applicable builtin algorithms will be used.
             cpu_size (str): Size of the CPU for the user-defined algorithms during training.
             memory (int): Memory (in GB) for the user-defined algorithms during training.
             algorithm_training_configs (list): List of algorithm specifc training configs that will be part of the model training AutoML run.
@@ -5142,7 +5178,7 @@ Creates a new feature group defined as the union of other feature group versions
             deployment_ids (list): List of unique string identifiers of deployments to automatically deploy to.
             feature_group_ids (list): List of feature group IDs provided by the user to train the model on.
             custom_algorithms (list): List of user-defined algorithms to train. If not set, will honor the runs from the last time and applicable new custom algorithms.
-            builtin_algorithms (list): List of the built-in algorithms provided by Abacus.AI to train. If not set, will honor the runs from the last time and applicable new built-in algorithms.
+            builtin_algorithms (list): List of algorithm names or algorithm IDs of Abacus.AI built-in algorithms to train. If not set, will honor the runs from the last time and applicable new built-in algorithms.
             custom_algorithm_configs (dict): User-defined training configs for each custom algorithm.
             cpu_size (str): Size of the CPU for the user-defined algorithms during training.
             memory (int): Memory (in GB) for the user-defined algorithms during training.
@@ -5167,13 +5203,13 @@ Creates a new feature group defined as the union of other feature group versions
             model_version (str): The unique identifier of the model version to delete."""
         return self._call_api('deleteModelVersion', 'DELETE', query_params={'modelVersion': model_version})
 
-    def export_model_artifact_as_feature_group(self, model_version: str, table_name: str, artifact_type: str) -> FeatureGroup:
+    def export_model_artifact_as_feature_group(self, model_version: str, table_name: str, artifact_type: Union[dict, EvalArtifactType] = None) -> FeatureGroup:
         """Exports metric artifact data for a model as a feature group.
 
         Args:
             model_version (str): Unique string identifier for the version of the model.
             table_name (str): Name of the feature group table to create.
-            artifact_type (str): EvalArtifact enum specifying which artifact to export.
+            artifact_type (EvalArtifactType): eval artifact type to export.
 
         Returns:
             FeatureGroup: The created feature group."""
@@ -6641,7 +6677,7 @@ Creates a new feature group defined as the union of other feature group versions
 
         Returns:
             FeatureGroupRow: The feature group row that was upserted."""
-        return self._call_api('upsertData', 'POST', query_params={'streamingToken': streaming_token}, body={'featureGroupId': feature_group_id, 'data': data}, parse_type=FeatureGroupRow)
+        return self._proxy_request('upsertData', 'POST', query_params={'streamingToken': streaming_token}, body={'featureGroupId': feature_group_id, 'data': data}, parse_type=FeatureGroupRow, is_sync=True)
 
     def upsert_online_data(self, feature_group_id: str, data: dict) -> FeatureGroupRow:
         """Update new data into the feature group for a given lookup key record ID if the record ID is found; otherwise, insert new data into the feature group.
@@ -7065,13 +7101,13 @@ Creates a new feature group defined as the union of other feature group versions
             Algorithm: The new custom model can be used for training."""
         return self._call_api('updateAlgorithm', 'PATCH', query_params={}, body={'algorithm': algorithm, 'sourceCode': source_code, 'trainingDataParameterNamesMapping': training_data_parameter_names_mapping, 'trainingConfigParameterName': training_config_parameter_name, 'trainFunctionName': train_function_name, 'predictFunctionName': predict_function_name, 'predictManyFunctionName': predict_many_function_name, 'initializeFunctionName': initialize_function_name, 'configOptions': config_options, 'isDefaultEnabled': is_default_enabled, 'useGpu': use_gpu, 'packageRequirements': package_requirements}, parse_type=Algorithm)
 
-    def list_builtin_algorithms(self, project_id: str, feature_group_ids: list, training_config: dict = None) -> List[Algorithm]:
-        """Return list of built-in algorithms based on given input.
+    def list_builtin_algorithms(self, project_id: str, feature_group_ids: list, training_config: Union[dict, TrainingConfig] = None) -> List[Algorithm]:
+        """Return list of built-in algorithms based on given input data and training config.
 
         Args:
             project_id (str): Unique string identifier associated with the project.
-            feature_group_ids (list): List of feature group identifiers applied to the algorithms.
-            training_config (dict): The training configuration key/value pairs used to train with the algorithm.
+            feature_group_ids (list): List of feature group IDs specifying input data.
+            training_config (TrainingConfig): The training config to be used for model training.
 
         Returns:
             list[Algorithm]: List of applicable builtin algorithms."""
@@ -7396,13 +7432,6 @@ Creates a new feature group defined as the union of other feature group versions
             ExternalApplication: The updated External Application."""
         return self._call_api('updateExternalApplication', 'POST', query_params={}, body={'externalApplicationId': external_application_id, 'name': name, 'theme': theme}, parse_type=ExternalApplication)
 
-    def list_external_applications(self) -> List[ExternalApplication]:
-        """Lists External Applications in an organization.
-
-        Returns:
-            list[ExternalApplication]: List of External Applications."""
-        return self._call_api('listExternalApplications', 'POST', query_params={}, body={}, parse_type=ExternalApplication)
-
     def delete_external_application(self, external_application_id: str):
         """Deletes an External Application.
 
@@ -7483,7 +7512,7 @@ Creates a new feature group defined as the union of other feature group versions
             LlmParameters: The parameters for LLM using the given inputs."""
         return self._call_api('getLLMParameters', 'POST', query_params={}, body={'prompt': prompt, 'systemMessage': system_message, 'llmName': llm_name, 'maxTokens': max_tokens}, parse_type=LlmParameters, timeout=300)
 
-    def generate_code_for_data_query_using_llm(self, query: str, feature_group_ids: list, prompt_context: str = None, llm_name: str = None, temperature: float = None) -> str:
+    def generate_code_for_data_query_using_llm(self, query: str, feature_group_ids: list, prompt_context: str = None, llm_name: str = None, temperature: float = None) -> LlmGeneratedCode:
         """Execute a data query using a large language model in an async fashion.
 
         Args:
@@ -7491,8 +7520,24 @@ Creates a new feature group defined as the union of other feature group versions
             feature_group_ids (list): A list of feature group IDs that the query should be executed against.
             prompt_context (str): The context message used to construct the prompt for the language model. If not provide, a default context message is used.
             llm_name (str): The name of the language model to use. If not provided, the default language model is used.
-            temperature (float): The temperature to use for the language model if supported. If not provided, the default temperature is used."""
-        return self._proxy_request('GenerateCodeForDataQueryUsingLlm', 'POST', query_params={}, body={'query': query, 'featureGroupIds': feature_group_ids, 'promptContext': prompt_context, 'llmName': llm_name, 'temperature': temperature})
+            temperature (float): The temperature to use for the language model if supported. If not provided, the default temperature is used.
+
+        Returns:
+            LlmGeneratedCode: The generated SQL code."""
+        return self._proxy_request('GenerateCodeForDataQueryUsingLlm', 'POST', query_params={}, body={'query': query, 'featureGroupIds': feature_group_ids, 'promptContext': prompt_context, 'llmName': llm_name, 'temperature': temperature}, parse_type=LlmGeneratedCode)
+
+    def extract_data_using_llm(self, field_descriptors: list, document_id: str = None, document_text: str = None, llm_name: str = None) -> ExtractedFields:
+        """Extract fields from a document using a large language model.
+
+        Args:
+            field_descriptors (list): A list of fields to extract from the document.
+            document_id (str): The ID of the document to query.
+            document_text (str): The text of the document to query. Only used if document_id is not provided.
+            llm_name (str): The name of the language model to use. If not provided, the default language model is used.
+
+        Returns:
+            ExtractedFields: The response from the document query."""
+        return self._call_api('extractDataUsingLLM', 'POST', query_params={}, body={'fieldDescriptors': field_descriptors, 'documentId': document_id, 'documentText': document_text, 'llmName': llm_name}, parse_type=ExtractedFields)
 
     def create_document_retriever(self, project_id: str, name: str, feature_group_id: str, document_retriever_config: Union[dict, DocumentRetrieverConfig] = None) -> DocumentRetriever:
         """Returns a document retriever that stores embeddings for document chunks in a feature group.

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/document_retriever.py

@@ -162,7 +162,7 @@ class DocumentRetriever(AbstractApiClass):
         """
         return self.describe().latest_document_retriever_version.status
 
-    def get_matching_documents(self, 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):
+    def get_matching_documents(self, 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):
         """
         Lookup document retrievers and return the matching documents from the document retriever deployed with given query.
 
@@ -179,8 +179,9 @@ class DocumentRetriever(AbstractApiClass):
             max_words (int): If provided, will limit the total number of words in the results to the value specified.
             num_retrieval_margin_words (int): If provided, will add this number of words from left and right of the returned chunks.
             max_words_per_chunk (int): If provided, will limit the number of words in each chunk to the value specified. If the value provided is smaller than the actual size of chunk on disk, which is determined during document retriever creation, the actual size of chunk will be used. I.e, chunks looked up from document retrievers will not be split into smaller chunks during lookup due to this setting.
+            score_multiplier_column (str): If provided, will use the values in this column to modify the relevance score of the returned chunks. Values in this column must be numeric.
 
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever.
         """
-        return self.client.get_matching_documents(self.document_retriever_id, query, filters, limit, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk)
+        return self.client.get_matching_documents(self.document_retriever_id, query, filters, limit, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column)

abacusai-0.79.2/abacusai/extracted_fields.py

@@ -0,0 +1,35 @@
+from .return_class import AbstractApiClass
+
+
+class ExtractedFields(AbstractApiClass):
+    """
+        The fields extracted from a document.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            data (dict): The data for the document.
+            rawLlmResponse (str): The raw llm response. Only returned if it could not be parsed to json.
+    """
+
+    def __init__(self, client, data=None, rawLlmResponse=None):
+        super().__init__(client, None)
+        self.data = data
+        self.raw_llm_response = rawLlmResponse
+
+    def __repr__(self):
+        repr_dict = {f'data': repr(
+            self.data), f'raw_llm_response': repr(self.raw_llm_response)}
+        class_name = "ExtractedFields"
+        repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
+        ) if getattr(self, key, None) is not None])
+        return f"{class_name}({repr_str})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        resp = {'data': self.data, 'raw_llm_response': self.raw_llm_response}
+        return {key: value for key, value in resp.items() if value is not None}

abacusai-0.79.2/abacusai/llm_generated_code.py

@@ -0,0 +1,32 @@
+from .return_class import AbstractApiClass
+
+
+class LlmGeneratedCode(AbstractApiClass):
+    """
+        Code generated by LLM.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            sql (str): SQL query generated by LLM.
+    """
+
+    def __init__(self, client, sql=None):
+        super().__init__(client, None)
+        self.sql = sql
+
+    def __repr__(self):
+        repr_dict = {f'sql': repr(self.sql)}
+        class_name = "LlmGeneratedCode"
+        repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
+        ) if getattr(self, key, None) is not None])
+        return f"{class_name}({repr_str})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        resp = {'sql': self.sql}
+        return {key: value for key, value in resp.items() if value is not None}

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/model.py

@@ -282,7 +282,7 @@ class Model(AbstractApiClass):
             deployment_ids (list): List of unique string identifiers of deployments to automatically deploy to.
             feature_group_ids (list): List of feature group IDs provided by the user to train the model on.
             custom_algorithms (list): List of user-defined algorithms to train. If not set, will honor the runs from the last time and applicable new custom algorithms.
-            builtin_algorithms (list): List of the built-in algorithms provided by Abacus.AI to train. If not set, will honor the runs from the last time and applicable new built-in algorithms.
+            builtin_algorithms (list): List of algorithm names or algorithm IDs of Abacus.AI built-in algorithms to train. If not set, will honor the runs from the last time and applicable new built-in algorithms.
             custom_algorithm_configs (dict): User-defined training configs for each custom algorithm.
             cpu_size (str): Size of the CPU for the user-defined algorithms during training.
             memory (int): Memory (in GB) for the user-defined algorithms during training.

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/model_version.py

@@ -1,6 +1,7 @@
 import time
+from typing import Union
 
-from .api_class import DeployableAlgorithm, TrainingConfig
+from .api_class import DeployableAlgorithm, EvalArtifactType, TrainingConfig
 from .code_source import CodeSource
 from .return_class import AbstractApiClass
 
@@ -148,13 +149,13 @@ class ModelVersion(AbstractApiClass):
         """
         return self.client.delete_model_version(self.model_version)
 
-    def export_model_artifact_as_feature_group(self, table_name: str, artifact_type: str):
+    def export_model_artifact_as_feature_group(self, table_name: str, artifact_type: Union[dict, EvalArtifactType] = None):
         """
         Exports metric artifact data for a model as a feature group.
 
         Args:
             table_name (str): Name of the feature group table to create.
-            artifact_type (str): EvalArtifact enum specifying which artifact to export.
+            artifact_type (EvalArtifactType): eval artifact type to export.
 
         Returns:
             FeatureGroup: The created feature group.

{abacusai-0.79.0 → abacusai-0.79.2}/abacusai/project.py

@@ -220,10 +220,7 @@ class Project(AbstractApiClass):
 
     def train_model(self, name: str = None, training_config: Union[dict, TrainingConfig] = None, feature_group_ids: list = None, refresh_schedule: str = None, custom_algorithms: list = None, custom_algorithms_only: bool = False, custom_algorithm_configs: dict = None, builtin_algorithms: list = None, cpu_size: str = None, memory: int = None, algorithm_training_configs: list = None):
         """
-        Train a model for the specified project.
-
-        This method trains a model in the given project, using user-specified training configurations defined in the `getTrainingConfigOptions` method.
-
+        Create a new model and start its training in the given project.
 
         Args:
             name (str): The name of the model. Defaults to "<Project Name> Model".
@@ -233,7 +230,7 @@ class Project(AbstractApiClass):
             custom_algorithms (list): List of user-defined algorithms to train. If not set, the default enabled custom algorithms will be used.
             custom_algorithms_only (bool): Whether to only run custom algorithms.
             custom_algorithm_configs (dict): Configs for each user-defined algorithm; key is the algorithm name, value is the config serialized to JSON.
-            builtin_algorithms (list): List of IDs of the builtin algorithms provided by Abacus.AI to train. If not set, all applicable builtin algorithms will be used.
+            builtin_algorithms (list): List of algorithm names or algorithm IDs of the builtin algorithms provided by Abacus.AI to train. If not set, all applicable builtin algorithms will be used.
             cpu_size (str): Size of the CPU for the user-defined algorithms during training.
             memory (int): Memory (in GB) for the user-defined algorithms during training.
             algorithm_training_configs (list): List of algorithm specifc training configs that will be part of the model training AutoML run.
@@ -567,13 +564,13 @@ class Project(AbstractApiClass):
         """
         return self.client.list_graph_dashboards(self.project_id)
 
-    def list_builtin_algorithms(self, feature_group_ids: list, training_config: dict = None):
+    def list_builtin_algorithms(self, feature_group_ids: list, training_config: Union[dict, TrainingConfig] = None):
         """
-        Return list of built-in algorithms based on given input.
+        Return list of built-in algorithms based on given input data and training config.
 
         Args:
-            feature_group_ids (list): List of feature group identifiers applied to the algorithms.
-            training_config (dict): The training configuration key/value pairs used to train with the algorithm.
+            feature_group_ids (list): List of feature group IDs specifying input data.
+            training_config (TrainingConfig): The training config to be used for model training.
 
         Returns:
             list[Algorithm]: List of applicable builtin algorithms.