abacusai 0.74.0__tar.gz → 0.75.5__tar.gz

{abacusai-0.74.0/abacusai.egg-info → abacusai-0.75.5}/PKG-INFO

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

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/__init__.py

@@ -4,4 +4,4 @@ from .prediction_client import PredictionClient
 from .streaming_client import StreamingClient
 
 
-__version__ = "0.74.0"
+__version__ = "0.75.5"

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/agent.py

@@ -13,28 +13,32 @@ class Agent(AbstractApiClass):
             agentId (str): The unique identifier of the agent.
             createdAt (str): Date and time at which the agent was created.
             projectId (str): The project this agent belongs to.
+            notebookId (str): The notebook associated with the agent.
             predictFunctionName (str): Name of the function found in the source code that will be executed run predictions through agent. It is not executed when this function is run.
             sourceCode (str): Python code used to make the agent.
             agentConfig (dict): The config options used to create this agent.
+            memory (int): Memory in GB specified for the deployment resources for 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, predictFunctionName=None, sourceCode=None, agentConfig=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, codeSource={}, latestAgentVersion={}):
         super().__init__(client, agentId)
         self.name = name
         self.agent_id = agentId
         self.created_at = createdAt
         self.project_id = projectId
+        self.notebook_id = notebookId
         self.predict_function_name = predictFunctionName
         self.source_code = sourceCode
         self.agent_config = agentConfig
+        self.memory = memory
         self.code_source = client._build_class(CodeSource, codeSource)
         self.latest_agent_version = client._build_class(
             AgentVersion, latestAgentVersion)
 
     def __repr__(self):
-        return f"Agent(name={repr(self.name)},\n  agent_id={repr(self.agent_id)},\n  created_at={repr(self.created_at)},\n  project_id={repr(self.project_id)},\n  predict_function_name={repr(self.predict_function_name)},\n  source_code={repr(self.source_code)},\n  agent_config={repr(self.agent_config)},\n  code_source={repr(self.code_source)},\n  latest_agent_version={repr(self.latest_agent_version)})"
+        return f"Agent(name={repr(self.name)},\n  agent_id={repr(self.agent_id)},\n  created_at={repr(self.created_at)},\n  project_id={repr(self.project_id)},\n  notebook_id={repr(self.notebook_id)},\n  predict_function_name={repr(self.predict_function_name)},\n  source_code={repr(self.source_code)},\n  agent_config={repr(self.agent_config)},\n  memory={repr(self.memory)},\n  code_source={repr(self.code_source)},\n  latest_agent_version={repr(self.latest_agent_version)})"
 
     def to_dict(self):
         """
@@ -43,7 +47,7 @@ class Agent(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'name': self.name, 'agent_id': self.agent_id, 'created_at': self.created_at, 'project_id': self.project_id, 'predict_function_name': self.predict_function_name, 'source_code': self.source_code, 'agent_config': self.agent_config, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version)}
+        return {'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, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version)}
 
     def refresh(self):
         """

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/algorithm.py

@@ -22,10 +22,11 @@ class Algorithm(AbstractApiClass):
             algorithmId (str): The unique identifier of the algorithm
             useGpu (bool): Whether to use gpu for model training
             algorithmTrainingConfig (dict): The algorithm specific training config
+            isRealtimeDeployable (bool): Whether or not the algorithm is allowed to be deployed in real time
             codeSource (CodeSource): Info about the source code of the algorithm
     """
 
-    def __init__(self, client, name=None, problemType=None, createdAt=None, updatedAt=None, isDefaultEnabled=None, trainingInputMappings=None, trainFunctionName=None, predictFunctionName=None, predictManyFunctionName=None, initializeFunctionName=None, configOptions=None, algorithmId=None, useGpu=None, algorithmTrainingConfig=None, codeSource={}):
+    def __init__(self, client, name=None, problemType=None, createdAt=None, updatedAt=None, isDefaultEnabled=None, trainingInputMappings=None, trainFunctionName=None, predictFunctionName=None, predictManyFunctionName=None, initializeFunctionName=None, configOptions=None, algorithmId=None, useGpu=None, algorithmTrainingConfig=None, isRealtimeDeployable=None, codeSource={}):
         super().__init__(client, algorithmId)
         self.name = name
         self.problem_type = problemType
@@ -41,10 +42,11 @@ class Algorithm(AbstractApiClass):
         self.algorithm_id = algorithmId
         self.use_gpu = useGpu
         self.algorithm_training_config = algorithmTrainingConfig
+        self.is_realtime_deployable = isRealtimeDeployable
         self.code_source = client._build_class(CodeSource, codeSource)
 
     def __repr__(self):
-        return f"Algorithm(name={repr(self.name)},\n  problem_type={repr(self.problem_type)},\n  created_at={repr(self.created_at)},\n  updated_at={repr(self.updated_at)},\n  is_default_enabled={repr(self.is_default_enabled)},\n  training_input_mappings={repr(self.training_input_mappings)},\n  train_function_name={repr(self.train_function_name)},\n  predict_function_name={repr(self.predict_function_name)},\n  predict_many_function_name={repr(self.predict_many_function_name)},\n  initialize_function_name={repr(self.initialize_function_name)},\n  config_options={repr(self.config_options)},\n  algorithm_id={repr(self.algorithm_id)},\n  use_gpu={repr(self.use_gpu)},\n  algorithm_training_config={repr(self.algorithm_training_config)},\n  code_source={repr(self.code_source)})"
+        return f"Algorithm(name={repr(self.name)},\n  problem_type={repr(self.problem_type)},\n  created_at={repr(self.created_at)},\n  updated_at={repr(self.updated_at)},\n  is_default_enabled={repr(self.is_default_enabled)},\n  training_input_mappings={repr(self.training_input_mappings)},\n  train_function_name={repr(self.train_function_name)},\n  predict_function_name={repr(self.predict_function_name)},\n  predict_many_function_name={repr(self.predict_many_function_name)},\n  initialize_function_name={repr(self.initialize_function_name)},\n  config_options={repr(self.config_options)},\n  algorithm_id={repr(self.algorithm_id)},\n  use_gpu={repr(self.use_gpu)},\n  algorithm_training_config={repr(self.algorithm_training_config)},\n  is_realtime_deployable={repr(self.is_realtime_deployable)},\n  code_source={repr(self.code_source)})"
 
     def to_dict(self):
         """
@@ -53,4 +55,4 @@ class Algorithm(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'name': self.name, 'problem_type': self.problem_type, 'created_at': self.created_at, 'updated_at': self.updated_at, 'is_default_enabled': self.is_default_enabled, 'training_input_mappings': self.training_input_mappings, 'train_function_name': self.train_function_name, 'predict_function_name': self.predict_function_name, 'predict_many_function_name': self.predict_many_function_name, 'initialize_function_name': self.initialize_function_name, 'config_options': self.config_options, 'algorithm_id': self.algorithm_id, 'use_gpu': self.use_gpu, 'algorithm_training_config': self.algorithm_training_config, 'code_source': self._get_attribute_as_dict(self.code_source)}
+        return {'name': self.name, 'problem_type': self.problem_type, 'created_at': self.created_at, 'updated_at': self.updated_at, 'is_default_enabled': self.is_default_enabled, 'training_input_mappings': self.training_input_mappings, 'train_function_name': self.train_function_name, 'predict_function_name': self.predict_function_name, 'predict_many_function_name': self.predict_many_function_name, 'initialize_function_name': self.initialize_function_name, 'config_options': self.config_options, 'algorithm_id': self.algorithm_id, 'use_gpu': self.use_gpu, 'algorithm_training_config': self.algorithm_training_config, 'is_realtime_deployable': self.is_realtime_deployable, 'code_source': self._get_attribute_as_dict(self.code_source)}

abacusai-0.75.5/abacusai/annotation_document.py

@@ -0,0 +1,35 @@
+from .return_class import AbstractApiClass
+
+
+class AnnotationDocument(AbstractApiClass):
+    """
+        Document to be annotated.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            docId (str): The docstore Document ID of the document.
+            featureGroupRowIdentifier (str): The key value of the feature group row the annotation is on. Usually the primary key value.
+            featureGroupRowIndex (int): The index of the document row in the feature group.
+            totalRows (int): The total number of rows in the feature group.
+            isAnnotationPresent (bool): Whether the document already has an annotation. Returns None if feature group is not under annotations review mode.
+    """
+
+    def __init__(self, client, docId=None, featureGroupRowIdentifier=None, featureGroupRowIndex=None, totalRows=None, isAnnotationPresent=None):
+        super().__init__(client, None)
+        self.doc_id = docId
+        self.feature_group_row_identifier = featureGroupRowIdentifier
+        self.feature_group_row_index = featureGroupRowIndex
+        self.total_rows = totalRows
+        self.is_annotation_present = isAnnotationPresent
+
+    def __repr__(self):
+        return f"AnnotationDocument(doc_id={repr(self.doc_id)},\n  feature_group_row_identifier={repr(self.feature_group_row_identifier)},\n  feature_group_row_index={repr(self.feature_group_row_index)},\n  total_rows={repr(self.total_rows)},\n  is_annotation_present={repr(self.is_annotation_present)})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        return {'doc_id': self.doc_id, 'feature_group_row_identifier': self.feature_group_row_identifier, 'feature_group_row_index': self.feature_group_row_index, 'total_rows': self.total_rows, 'is_annotation_present': self.is_annotation_present}

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/__init__.py

@@ -1,9 +1,10 @@
 from .batch_prediction import *
+from .blob_input import *
 from .dataset import *
+from .document_retriever import *
 from .enums import *
 from .feature_group import *
 from .model import *
 from .project import *
 from .python_functions import *
 from .refresh import *
-from .vector_store import *

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/abstract.py

@@ -41,6 +41,10 @@ class ApiClass(ABC):
         if inspect.isabstract(self):
             raise ValueError(f'Cannot instantiate abstract class {self.__class__.__name__}')
 
+    @classmethod
+    def _get_builder(cls):
+        return None
+
     def to_dict(self):
         """
         Standardizes converting an ApiClass to dictionary.
@@ -76,6 +80,8 @@ class ApiClass(ABC):
 
     @classmethod
     def from_dict(cls, input_dict: dict):
+        if builder := cls._get_builder():
+            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()}
         return cls(**input_dict)
@@ -115,5 +121,6 @@ class _ApiClassFactory(ABC):
                 config_class = cls.config_abstract_class
         if config_class is None:
             raise ValueError(f'Invalid type {config_class_type}')
-
-        return config_class.from_dict(config)
+        if not config_class._upper_snake_case_keys:
+            config = {snake_case(k): v for k, v in config.items()}
+        return config_class(**config)

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/batch_prediction.py

@@ -10,6 +10,11 @@ class BatchPredictionArgs(ApiClass):
 
     kwargs: dict = dataclasses.field(default_factory=dict)
     problem_type: enums.ProblemType = dataclasses.field(default=None)
+    name: str = 'batch_prediction_args'
+
+    @classmethod
+    def _get_builder(cls):
+        return _BatchPredictionArgsFactory
 
 
 @dataclasses.dataclass
@@ -179,7 +184,7 @@ class ThemeAnalysisBatchPredictionArgs(BatchPredictionArgs):
     """
     Batch Prediction Config for the THEME_ANALYSIS problem type
     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.
+        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.
         analysis_frequency (str): The length of each analysis interval.
         start_date (str): The end point for predictions.
         analysis_days (int): How many days to analyze.
@@ -193,6 +198,21 @@ class ThemeAnalysisBatchPredictionArgs(BatchPredictionArgs):
         self.problem_type = enums.ProblemType.THEME_ANALYSIS
 
 
+@dataclasses.dataclass
+class ChatLLMBatchPredictionArgs(BatchPredictionArgs):
+    """
+    Batch Prediction Config for the ChatLLM problem type
+    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.
+        product (bool): Generate a response for every question and chunk combination
+    """
+    for_eval: bool = dataclasses.field(default=None)
+    product: bool = None
+
+    def __post_init__(self):
+        self.problem_type = enums.ProblemType.CHAT_LLM
+
+
 @dataclasses.dataclass
 class _BatchPredictionArgsFactory(_ApiClassFactory):
     config_abstract_class = BatchPredictionArgs
@@ -207,4 +227,5 @@ class _BatchPredictionArgsFactory(_ApiClassFactory):
         enums.ProblemType.PRETRAINED_MODELS: PretrainedModelsBatchPredictionArgs,
         enums.ProblemType.SENTENCE_BOUNDARY_DETECTION: SentenceBoundaryDetectionBatchPredictionArgs,
         enums.ProblemType.THEME_ANALYSIS: ThemeAnalysisBatchPredictionArgs,
+        enums.ProblemType.CHAT_LLM: ChatLLMBatchPredictionArgs,
     }

abacusai-0.75.5/abacusai/api_class/blob_input.py

@@ -0,0 +1,32 @@
+import dataclasses
+
+import magic
+
+from .abstract import ApiClass
+
+
+@dataclasses.dataclass
+class BlobInput(ApiClass):
+    """
+    Binary large object input data.
+
+    Args:
+        filename (str): The original filename of the blob.
+        contents (bytes): The binary contents of the blob.
+        mime_type (str): The mime type of the blob.
+        size (int): The size of the blob in bytes.
+    """
+    filename: str
+    contents: bytes
+    mime_type: str
+    size: int
+
+    @classmethod
+    def from_local_file(cls, file_path: str) -> 'BlobInput':
+        with open(file_path, 'rb') as f:
+            contents = f.read()
+        return cls.from_contents(contents, filename=file_path)
+
+    @classmethod
+    def from_contents(cls, contents: bytes, filename: str = None) -> 'BlobInput':
+        return cls(filename=filename, contents=contents, mime_type=magic.from_buffer(contents, mime=True), size=len(contents))

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/enums.py

@@ -21,6 +21,7 @@ class ProblemType(ApiEnum):
     AI_AGENT = 'ai_agent'
     ANOMALY_DETECTION = 'anomaly_new'
     ANOMALY_OUTLIERS = 'anomaly'
+    EVENT_ANOMALY = 'event_anomaly'
     CLUSTERING = 'clustering'
     CLUSTERING_TIMESERIES = 'clustering_timeseries'
     CUMULATIVE_FORECASTING = 'cumulative_forecasting'
@@ -332,3 +333,14 @@ class VectorStoreTextEncoder(ApiEnum):
     OPENAI = 'OPENAI'
     SENTENCE_BERT = 'SENTENCE_BERT'
     E5_SMALL = 'E5_SMALL'
+
+
+class LLMName(ApiEnum):
+    OPENAI_GPT4 = 'OPENAI_GPT4'
+    OPENAI_GPT3_5 = 'OPENAI_GPT3_5'
+    OPENAI_GPT3_5_SHORT = 'OPENAI_GPT3_5_SHORT'
+    CLAUDE_V2 = 'CLAUDE_V2'
+    ABACUS = 'ABACUS'
+    ABACUS_LONG = 'ABACUS_LONG'
+    ABACUS_LARGE = 'ABACUS_LARGE'
+    PALM = 'PALM'

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/feature_group.py

@@ -10,6 +10,11 @@ class SamplingConfig(ApiClass):
     """
     An abstract class for the sampling config of a feature group
     """
+
+    @classmethod
+    def _get_builder(cls):
+        return _SamplingConfigFactory
+
     def __post_init__(self):
         if self.__class__ == SamplingConfig:
             raise TypeError('Cannot instantiate abstract SamplingConfig class.')
@@ -59,6 +64,11 @@ class MergeConfig(ApiClass):
     """
     An abstract class for the merge config of a feature group
     """
+
+    @classmethod
+    def _get_builder(self):
+        return _MergeConfigFactory
+
     def __post_init__(self):
         if self.__class__ == MergeConfig:
             raise TypeError('Cannot instantiate abstract MergeConfig class.')

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/model.py

@@ -14,6 +14,10 @@ class TrainingConfig(ApiClass):
     problem_type: enums.ProblemType = dataclasses.field(default=None, repr=False, init=False)
     algorithm: str = dataclasses.field(default=None)
 
+    @classmethod
+    def _get_builder(cls):
+        return _TrainingConfigFactory
+
 
 @dataclasses.dataclass
 class PersonalizationTrainingConfig(TrainingConfig):
@@ -123,7 +127,7 @@ class RegressionTrainingConfig(TrainingConfig):
         test_row_indicator (str): Column indicating which rows to use for training (TRAIN) and testing (TEST). Validation (VAL) can also be specified.
         rebalance_classes (bool): Class weights are computed as the inverse of the class frequency from the training dataset when this option is selected as "Yes". It is useful when the classes in the dataset are unbalanced.
                                   Re-balancing classes generally boosts recall at the cost of precision on rare classes.
-        rare_class_augmentation_threshold (float): Augments any rare class whose relative frequency with respect to the most frequent class is less than this threshold. Default = 0.1
+        rare_class_augmentation_threshold (float): Augments any rare class whose relative frequency with respect to the most frequent class is less than this threshold. Default = 0.1 for classification problems with rare classes.
         augmentation_strategy (RegressionAugmentationStrategy): Strategy to deal with class imbalance and data augmentation.
         training_rows_downsample_ratio (float): Uses this ratio to train on a sample of the dataset provided.
         active_labels_column (str): Specify a column to use as the active columns in a multi label setting.
@@ -166,7 +170,7 @@ class RegressionTrainingConfig(TrainingConfig):
 
     # data augmentation
     rebalance_classes: bool = dataclasses.field(default=None)
-    rare_class_augmentation_threshold: float = dataclasses.field(default=0.1)
+    rare_class_augmentation_threshold: float = dataclasses.field(default=None)
     augmentation_strategy: enums.RegressionAugmentationStrategy = dataclasses.field(default=None)
     training_rows_downsample_ratio: float = dataclasses.field(default=None)
 
@@ -549,6 +553,19 @@ class ClusteringTimeseriesTrainingConfig(TrainingConfig):
         self.problem_type = enums.ProblemType.CLUSTERING_TIMESERIES
 
 
+@dataclasses.dataclass
+class EventAnomalyTrainingConfig(TrainingConfig):
+    """
+    Training config for the EVENT_ANOMALY problem type
+    Args:
+        anomaly_fraction (float): The fraction of the dataset to classify as anomalous, between 0 and 0.5
+    """
+    anomaly_fraction: float = dataclasses.field(default=None)
+
+    def __post_init__(self):
+        self.problem_type = enums.ProblemType.EVENT_ANOMALY
+
+
 @dataclasses.dataclass
 class CumulativeForecastingTrainingConfig(TrainingConfig):
     """
@@ -613,8 +630,10 @@ class AIAgentTrainingConfig(TrainingConfig):
     Training config for the AI_AGENT problem type
     Args:
         description (str): Description of the agent function.
+        enable_binary_input (bool): If True, the agent will be able to accept binary data as inputs.
     """
     description: str = dataclasses.field(default=None)
+    enable_binary_input: bool = dataclasses.field(default=None)
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.AI_AGENT
@@ -670,7 +689,11 @@ class CustomAlgorithmTrainingConfig(TrainingConfig):
 class OptimizationTrainingConfig(TrainingConfig):
     """
     Training config for the OPTIMIZATION problem type
+    Args:
+        solve_time_limit (float): The maximum time in seconds to spend solving the problem. Accepts values between 0 and 86400.
+
     """
+    solve_time_limit: float = dataclasses.field(default=None)
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.OPTIMIZATION
@@ -690,6 +713,7 @@ class _TrainingConfigFactory(_ApiClassFactory):
         enums.ProblemType.DOCUMENT_CLASSIFICATION: DocumentClassificationTrainingConfig,
         enums.ProblemType.DOCUMENT_SUMMARIZATION: DocumentSummarizationTrainingConfig,
         enums.ProblemType.DOCUMENT_VISUALIZATION: DocumentVisualizationTrainingConfig,
+        enums.ProblemType.EVENT_ANOMALY: EventAnomalyTrainingConfig,
         enums.ProblemType.FORECASTING: ForecastingTrainingConfig,
         enums.ProblemType.NAMED_ENTITY_EXTRACTION: NamedEntityExtractionTrainingConfig,
         enums.ProblemType.NATURAL_LANGUAGE_SEARCH: NaturalLanguageSearchTrainingConfig,

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/api_class/refresh.py

@@ -9,6 +9,10 @@ from .abstract import ApiClass, _ApiClassFactory
 class FeatureGroupExportConfig(ApiClass):
     connector_type: enums.ConnectorType = dataclasses.field(default=None)
 
+    @classmethod
+    def _get_builder(cls):
+        return _FeatureGroupExportConfigFactory
+
 
 @dataclasses.dataclass
 class FileConnectorExportConfig(FeatureGroupExportConfig):

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/batch_prediction.py

@@ -18,7 +18,6 @@ class BatchPrediction(AbstractApiClass):
             name (str): Name given to the batch prediction object.
             deploymentId (str): The deployment used to make the predictions.
             fileConnectorOutputLocation (str): Contains information about where the batch predictions are written to.
-            globalPredictionArgs (dict): Argument(s) passed to every prediction call.
             databaseConnectorId (str): The database connector to write the results to.
             databaseOutputConfiguration (dict): Contains information about where the batch predictions are written to.
             explanations (bool): If true, explanations for each prediction will be created.
@@ -38,16 +37,16 @@ class BatchPrediction(AbstractApiClass):
             batchInputs (PredictionInput): Inputs to the batch prediction.
             latestBatchPredictionVersion (BatchPredictionVersion): The latest batch prediction version.
             refreshSchedules (RefreshSchedule): List of refresh schedules that dictate the next time the batch prediction will be run.
+            globalPredictionArgs (BatchPredictionArgs): Argument(s) passed to every prediction call.
     """
 
-    def __init__(self, client, batchPredictionId=None, createdAt=None, name=None, deploymentId=None, fileConnectorOutputLocation=None, globalPredictionArgs=None, databaseConnectorId=None, databaseOutputConfiguration=None, explanations=None, fileOutputFormat=None, connectorType=None, legacyInputLocation=None, featureGroupTableName=None, summaryFeatureGroupTableName=None, csvInputPrefix=None, csvPredictionPrefix=None, csvExplanationsPrefix=None, outputIncludesMetadata=None, resultInputColumns=None, modelMonitorId=None, modelVersion=None, algorithm=None, batchInputs={}, latestBatchPredictionVersion={}, refreshSchedules={}):
+    def __init__(self, client, batchPredictionId=None, createdAt=None, name=None, deploymentId=None, fileConnectorOutputLocation=None, databaseConnectorId=None, databaseOutputConfiguration=None, explanations=None, fileOutputFormat=None, connectorType=None, legacyInputLocation=None, featureGroupTableName=None, summaryFeatureGroupTableName=None, csvInputPrefix=None, csvPredictionPrefix=None, csvExplanationsPrefix=None, outputIncludesMetadata=None, resultInputColumns=None, modelMonitorId=None, modelVersion=None, algorithm=None, batchInputs={}, latestBatchPredictionVersion={}, refreshSchedules={}, globalPredictionArgs={}):
         super().__init__(client, batchPredictionId)
         self.batch_prediction_id = batchPredictionId
         self.created_at = createdAt
         self.name = name
         self.deployment_id = deploymentId
         self.file_connector_output_location = fileConnectorOutputLocation
-        self.global_prediction_args = globalPredictionArgs
         self.database_connector_id = databaseConnectorId
         self.database_output_configuration = databaseOutputConfiguration
         self.explanations = explanations
@@ -69,9 +68,11 @@ class BatchPrediction(AbstractApiClass):
             BatchPredictionVersion, latestBatchPredictionVersion)
         self.refresh_schedules = client._build_class(
             RefreshSchedule, refreshSchedules)
+        self.global_prediction_args = client._build_class(
+            BatchPredictionArgs, globalPredictionArgs)
 
     def __repr__(self):
-        return f"BatchPrediction(batch_prediction_id={repr(self.batch_prediction_id)},\n  created_at={repr(self.created_at)},\n  name={repr(self.name)},\n  deployment_id={repr(self.deployment_id)},\n  file_connector_output_location={repr(self.file_connector_output_location)},\n  global_prediction_args={repr(self.global_prediction_args)},\n  database_connector_id={repr(self.database_connector_id)},\n  database_output_configuration={repr(self.database_output_configuration)},\n  explanations={repr(self.explanations)},\n  file_output_format={repr(self.file_output_format)},\n  connector_type={repr(self.connector_type)},\n  legacy_input_location={repr(self.legacy_input_location)},\n  feature_group_table_name={repr(self.feature_group_table_name)},\n  summary_feature_group_table_name={repr(self.summary_feature_group_table_name)},\n  csv_input_prefix={repr(self.csv_input_prefix)},\n  csv_prediction_prefix={repr(self.csv_prediction_prefix)},\n  csv_explanations_prefix={repr(self.csv_explanations_prefix)},\n  output_includes_metadata={repr(self.output_includes_metadata)},\n  result_input_columns={repr(self.result_input_columns)},\n  model_monitor_id={repr(self.model_monitor_id)},\n  model_version={repr(self.model_version)},\n  algorithm={repr(self.algorithm)},\n  batch_inputs={repr(self.batch_inputs)},\n  latest_batch_prediction_version={repr(self.latest_batch_prediction_version)},\n  refresh_schedules={repr(self.refresh_schedules)})"
+        return f"BatchPrediction(batch_prediction_id={repr(self.batch_prediction_id)},\n  created_at={repr(self.created_at)},\n  name={repr(self.name)},\n  deployment_id={repr(self.deployment_id)},\n  file_connector_output_location={repr(self.file_connector_output_location)},\n  database_connector_id={repr(self.database_connector_id)},\n  database_output_configuration={repr(self.database_output_configuration)},\n  explanations={repr(self.explanations)},\n  file_output_format={repr(self.file_output_format)},\n  connector_type={repr(self.connector_type)},\n  legacy_input_location={repr(self.legacy_input_location)},\n  feature_group_table_name={repr(self.feature_group_table_name)},\n  summary_feature_group_table_name={repr(self.summary_feature_group_table_name)},\n  csv_input_prefix={repr(self.csv_input_prefix)},\n  csv_prediction_prefix={repr(self.csv_prediction_prefix)},\n  csv_explanations_prefix={repr(self.csv_explanations_prefix)},\n  output_includes_metadata={repr(self.output_includes_metadata)},\n  result_input_columns={repr(self.result_input_columns)},\n  model_monitor_id={repr(self.model_monitor_id)},\n  model_version={repr(self.model_version)},\n  algorithm={repr(self.algorithm)},\n  batch_inputs={repr(self.batch_inputs)},\n  latest_batch_prediction_version={repr(self.latest_batch_prediction_version)},\n  refresh_schedules={repr(self.refresh_schedules)},\n  global_prediction_args={repr(self.global_prediction_args)})"
 
     def to_dict(self):
         """
@@ -80,7 +81,7 @@ class BatchPrediction(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'batch_prediction_id': self.batch_prediction_id, 'created_at': self.created_at, 'name': self.name, 'deployment_id': self.deployment_id, 'file_connector_output_location': self.file_connector_output_location, 'global_prediction_args': self.global_prediction_args, 'database_connector_id': self.database_connector_id, 'database_output_configuration': self.database_output_configuration, 'explanations': self.explanations, 'file_output_format': self.file_output_format, 'connector_type': self.connector_type, 'legacy_input_location': self.legacy_input_location, 'feature_group_table_name': self.feature_group_table_name, 'summary_feature_group_table_name': self.summary_feature_group_table_name, 'csv_input_prefix': self.csv_input_prefix, 'csv_prediction_prefix': self.csv_prediction_prefix, 'csv_explanations_prefix': self.csv_explanations_prefix, 'output_includes_metadata': self.output_includes_metadata, 'result_input_columns': self.result_input_columns, 'model_monitor_id': self.model_monitor_id, 'model_version': self.model_version, 'algorithm': self.algorithm, 'batch_inputs': self._get_attribute_as_dict(self.batch_inputs), 'latest_batch_prediction_version': self._get_attribute_as_dict(self.latest_batch_prediction_version), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules)}
+        return {'batch_prediction_id': self.batch_prediction_id, 'created_at': self.created_at, 'name': self.name, 'deployment_id': self.deployment_id, 'file_connector_output_location': self.file_connector_output_location, 'database_connector_id': self.database_connector_id, 'database_output_configuration': self.database_output_configuration, 'explanations': self.explanations, 'file_output_format': self.file_output_format, 'connector_type': self.connector_type, 'legacy_input_location': self.legacy_input_location, 'feature_group_table_name': self.feature_group_table_name, 'summary_feature_group_table_name': self.summary_feature_group_table_name, 'csv_input_prefix': self.csv_input_prefix, 'csv_prediction_prefix': self.csv_prediction_prefix, 'csv_explanations_prefix': self.csv_explanations_prefix, 'output_includes_metadata': self.output_includes_metadata, 'result_input_columns': self.result_input_columns, 'model_monitor_id': self.model_monitor_id, 'model_version': self.model_version, 'algorithm': self.algorithm, 'batch_inputs': self._get_attribute_as_dict(self.batch_inputs), 'latest_batch_prediction_version': self._get_attribute_as_dict(self.latest_batch_prediction_version), 'refresh_schedules': self._get_attribute_as_dict(self.refresh_schedules), 'global_prediction_args': self._get_attribute_as_dict(self.global_prediction_args)}
 
     def start(self):
         """

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/batch_prediction_version.py

@@ -1,3 +1,4 @@
+from .api_class import BatchPredictionArgs
 from .prediction_input import PredictionInput
 from .return_class import AbstractApiClass
 
@@ -17,7 +18,6 @@ class BatchPredictionVersion(AbstractApiClass):
             modelVersion (str): The model version used to make the predictions
             predictionsStartedAt (str): Predictions start date and time
             predictionsCompletedAt (str): Predictions completion date and time
-            globalPredictionArgs (dict): Argument(s) passed to every prediction call
             databaseOutputError (bool): If true, there were errors reported by the database connector while writing
             totalPredictions (int): Number of predictions performed in this batch prediction job
             failedPredictions (int): Number of predictions that failed
@@ -42,9 +42,10 @@ class BatchPredictionVersion(AbstractApiClass):
             algoName (str): The name of the algorithm used to train the model
             algorithm (str): The algorithm that is currently deployed.
             batchInputs (PredictionInput): Inputs to the batch prediction
+            globalPredictionArgs (BatchPredictionArgs): Argument(s) passed to every prediction call
     """
 
-    def __init__(self, client, batchPredictionVersion=None, batchPredictionId=None, status=None, driftMonitorStatus=None, deploymentId=None, modelId=None, modelVersion=None, predictionsStartedAt=None, predictionsCompletedAt=None, globalPredictionArgs=None, databaseOutputError=None, totalPredictions=None, failedPredictions=None, databaseConnectorId=None, databaseOutputConfiguration=None, explanations=None, fileConnectorOutputLocation=None, fileOutputFormat=None, connectorType=None, legacyInputLocation=None, error=None, driftMonitorError=None, monitorWarnings=None, csvInputPrefix=None, csvPredictionPrefix=None, csvExplanationsPrefix=None, databaseOutputTotalWrites=None, databaseOutputFailedWrites=None, outputIncludesMetadata=None, resultInputColumns=None, modelMonitorVersion=None, algoName=None, algorithm=None, batchInputs={}):
+    def __init__(self, client, batchPredictionVersion=None, batchPredictionId=None, status=None, driftMonitorStatus=None, deploymentId=None, modelId=None, modelVersion=None, predictionsStartedAt=None, predictionsCompletedAt=None, databaseOutputError=None, totalPredictions=None, failedPredictions=None, databaseConnectorId=None, databaseOutputConfiguration=None, explanations=None, fileConnectorOutputLocation=None, fileOutputFormat=None, connectorType=None, legacyInputLocation=None, error=None, driftMonitorError=None, monitorWarnings=None, csvInputPrefix=None, csvPredictionPrefix=None, csvExplanationsPrefix=None, databaseOutputTotalWrites=None, databaseOutputFailedWrites=None, outputIncludesMetadata=None, resultInputColumns=None, modelMonitorVersion=None, algoName=None, algorithm=None, batchInputs={}, globalPredictionArgs={}):
         super().__init__(client, batchPredictionVersion)
         self.batch_prediction_version = batchPredictionVersion
         self.batch_prediction_id = batchPredictionId
@@ -55,7 +56,6 @@ class BatchPredictionVersion(AbstractApiClass):
         self.model_version = modelVersion
         self.predictions_started_at = predictionsStartedAt
         self.predictions_completed_at = predictionsCompletedAt
-        self.global_prediction_args = globalPredictionArgs
         self.database_output_error = databaseOutputError
         self.total_predictions = totalPredictions
         self.failed_predictions = failedPredictions
@@ -80,9 +80,11 @@ class BatchPredictionVersion(AbstractApiClass):
         self.algo_name = algoName
         self.algorithm = algorithm
         self.batch_inputs = client._build_class(PredictionInput, batchInputs)
+        self.global_prediction_args = client._build_class(
+            BatchPredictionArgs, globalPredictionArgs)
 
     def __repr__(self):
-        return f"BatchPredictionVersion(batch_prediction_version={repr(self.batch_prediction_version)},\n  batch_prediction_id={repr(self.batch_prediction_id)},\n  status={repr(self.status)},\n  drift_monitor_status={repr(self.drift_monitor_status)},\n  deployment_id={repr(self.deployment_id)},\n  model_id={repr(self.model_id)},\n  model_version={repr(self.model_version)},\n  predictions_started_at={repr(self.predictions_started_at)},\n  predictions_completed_at={repr(self.predictions_completed_at)},\n  global_prediction_args={repr(self.global_prediction_args)},\n  database_output_error={repr(self.database_output_error)},\n  total_predictions={repr(self.total_predictions)},\n  failed_predictions={repr(self.failed_predictions)},\n  database_connector_id={repr(self.database_connector_id)},\n  database_output_configuration={repr(self.database_output_configuration)},\n  explanations={repr(self.explanations)},\n  file_connector_output_location={repr(self.file_connector_output_location)},\n  file_output_format={repr(self.file_output_format)},\n  connector_type={repr(self.connector_type)},\n  legacy_input_location={repr(self.legacy_input_location)},\n  error={repr(self.error)},\n  drift_monitor_error={repr(self.drift_monitor_error)},\n  monitor_warnings={repr(self.monitor_warnings)},\n  csv_input_prefix={repr(self.csv_input_prefix)},\n  csv_prediction_prefix={repr(self.csv_prediction_prefix)},\n  csv_explanations_prefix={repr(self.csv_explanations_prefix)},\n  database_output_total_writes={repr(self.database_output_total_writes)},\n  database_output_failed_writes={repr(self.database_output_failed_writes)},\n  output_includes_metadata={repr(self.output_includes_metadata)},\n  result_input_columns={repr(self.result_input_columns)},\n  model_monitor_version={repr(self.model_monitor_version)},\n  algo_name={repr(self.algo_name)},\n  algorithm={repr(self.algorithm)},\n  batch_inputs={repr(self.batch_inputs)})"
+        return f"BatchPredictionVersion(batch_prediction_version={repr(self.batch_prediction_version)},\n  batch_prediction_id={repr(self.batch_prediction_id)},\n  status={repr(self.status)},\n  drift_monitor_status={repr(self.drift_monitor_status)},\n  deployment_id={repr(self.deployment_id)},\n  model_id={repr(self.model_id)},\n  model_version={repr(self.model_version)},\n  predictions_started_at={repr(self.predictions_started_at)},\n  predictions_completed_at={repr(self.predictions_completed_at)},\n  database_output_error={repr(self.database_output_error)},\n  total_predictions={repr(self.total_predictions)},\n  failed_predictions={repr(self.failed_predictions)},\n  database_connector_id={repr(self.database_connector_id)},\n  database_output_configuration={repr(self.database_output_configuration)},\n  explanations={repr(self.explanations)},\n  file_connector_output_location={repr(self.file_connector_output_location)},\n  file_output_format={repr(self.file_output_format)},\n  connector_type={repr(self.connector_type)},\n  legacy_input_location={repr(self.legacy_input_location)},\n  error={repr(self.error)},\n  drift_monitor_error={repr(self.drift_monitor_error)},\n  monitor_warnings={repr(self.monitor_warnings)},\n  csv_input_prefix={repr(self.csv_input_prefix)},\n  csv_prediction_prefix={repr(self.csv_prediction_prefix)},\n  csv_explanations_prefix={repr(self.csv_explanations_prefix)},\n  database_output_total_writes={repr(self.database_output_total_writes)},\n  database_output_failed_writes={repr(self.database_output_failed_writes)},\n  output_includes_metadata={repr(self.output_includes_metadata)},\n  result_input_columns={repr(self.result_input_columns)},\n  model_monitor_version={repr(self.model_monitor_version)},\n  algo_name={repr(self.algo_name)},\n  algorithm={repr(self.algorithm)},\n  batch_inputs={repr(self.batch_inputs)},\n  global_prediction_args={repr(self.global_prediction_args)})"
 
     def to_dict(self):
         """
@@ -91,7 +93,7 @@ class BatchPredictionVersion(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'batch_prediction_version': self.batch_prediction_version, 'batch_prediction_id': self.batch_prediction_id, 'status': self.status, 'drift_monitor_status': self.drift_monitor_status, 'deployment_id': self.deployment_id, 'model_id': self.model_id, 'model_version': self.model_version, 'predictions_started_at': self.predictions_started_at, 'predictions_completed_at': self.predictions_completed_at, 'global_prediction_args': self.global_prediction_args, 'database_output_error': self.database_output_error, 'total_predictions': self.total_predictions, 'failed_predictions': self.failed_predictions, 'database_connector_id': self.database_connector_id, 'database_output_configuration': self.database_output_configuration, 'explanations': self.explanations, 'file_connector_output_location': self.file_connector_output_location, 'file_output_format': self.file_output_format, 'connector_type': self.connector_type, 'legacy_input_location': self.legacy_input_location, 'error': self.error, 'drift_monitor_error': self.drift_monitor_error, 'monitor_warnings': self.monitor_warnings, 'csv_input_prefix': self.csv_input_prefix, 'csv_prediction_prefix': self.csv_prediction_prefix, 'csv_explanations_prefix': self.csv_explanations_prefix, 'database_output_total_writes': self.database_output_total_writes, 'database_output_failed_writes': self.database_output_failed_writes, 'output_includes_metadata': self.output_includes_metadata, 'result_input_columns': self.result_input_columns, 'model_monitor_version': self.model_monitor_version, 'algo_name': self.algo_name, 'algorithm': self.algorithm, 'batch_inputs': self._get_attribute_as_dict(self.batch_inputs)}
+        return {'batch_prediction_version': self.batch_prediction_version, 'batch_prediction_id': self.batch_prediction_id, 'status': self.status, 'drift_monitor_status': self.drift_monitor_status, 'deployment_id': self.deployment_id, 'model_id': self.model_id, 'model_version': self.model_version, 'predictions_started_at': self.predictions_started_at, 'predictions_completed_at': self.predictions_completed_at, 'database_output_error': self.database_output_error, 'total_predictions': self.total_predictions, 'failed_predictions': self.failed_predictions, 'database_connector_id': self.database_connector_id, 'database_output_configuration': self.database_output_configuration, 'explanations': self.explanations, 'file_connector_output_location': self.file_connector_output_location, 'file_output_format': self.file_output_format, 'connector_type': self.connector_type, 'legacy_input_location': self.legacy_input_location, 'error': self.error, 'drift_monitor_error': self.drift_monitor_error, 'monitor_warnings': self.monitor_warnings, 'csv_input_prefix': self.csv_input_prefix, 'csv_prediction_prefix': self.csv_prediction_prefix, 'csv_explanations_prefix': self.csv_explanations_prefix, 'database_output_total_writes': self.database_output_total_writes, 'database_output_failed_writes': self.database_output_failed_writes, 'output_includes_metadata': self.output_includes_metadata, 'result_input_columns': self.result_input_columns, 'model_monitor_version': self.model_monitor_version, 'algo_name': self.algo_name, 'algorithm': self.algorithm, 'batch_inputs': self._get_attribute_as_dict(self.batch_inputs), 'global_prediction_args': self._get_attribute_as_dict(self.global_prediction_args)}
 
     def download_batch_prediction_result_chunk(self, offset: int = 0, chunk_size: int = 10485760):
         """

{abacusai-0.74.0 → abacusai-0.75.5}/abacusai/chat_session.py

@@ -15,11 +15,12 @@ class ChatSession(AbstractApiClass):
             name (str): The name of the chat session
             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
             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, chatHistory={}, nextAiBuildingTask={}):
+    def __init__(self, client, answer=None, chatSessionId=None, projectId=None, name=None, createdAt=None, status=None, aiBuildingInProgress=None, chatHistory={}, nextAiBuildingTask={}):
         super().__init__(client, chatSessionId)
         self.answer = answer
         self.chat_session_id = chatSessionId
@@ -27,12 +28,13 @@ class ChatSession(AbstractApiClass):
         self.name = name
         self.created_at = createdAt
         self.status = status
+        self.ai_building_in_progress = aiBuildingInProgress
         self.chat_history = client._build_class(ChatMessage, chatHistory)
         self.next_ai_building_task = client._build_class(
             AiBuildingTask, nextAiBuildingTask)
 
     def __repr__(self):
-        return f"ChatSession(answer={repr(self.answer)},\n  chat_session_id={repr(self.chat_session_id)},\n  project_id={repr(self.project_id)},\n  name={repr(self.name)},\n  created_at={repr(self.created_at)},\n  status={repr(self.status)},\n  chat_history={repr(self.chat_history)},\n  next_ai_building_task={repr(self.next_ai_building_task)})"
+        return f"ChatSession(answer={repr(self.answer)},\n  chat_session_id={repr(self.chat_session_id)},\n  project_id={repr(self.project_id)},\n  name={repr(self.name)},\n  created_at={repr(self.created_at)},\n  status={repr(self.status)},\n  ai_building_in_progress={repr(self.ai_building_in_progress)},\n  chat_history={repr(self.chat_history)},\n  next_ai_building_task={repr(self.next_ai_building_task)})"
 
     def to_dict(self):
         """
@@ -41,7 +43,7 @@ class ChatSession(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'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, '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 {'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)}
 
     def get(self):
         """