abacusai 0.52.1__tar.gz → 0.61.0__tar.gz

{abacusai-0.52.1/abacusai.egg-info → abacusai-0.61.0}/PKG-INFO

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

{abacusai-0.52.1 → abacusai-0.61.0}/abacusai/__init__.py

@@ -1,6 +1,7 @@
 from .api_class import *
 from .client import ApiClient, ApiException, ClientOptions, ReadOnlyClient
 from .prediction_client import PredictionClient
+from .streaming_client import StreamingClient
 
 
-__version__ = "0.52.0"
+__version__ = "0.61.0"

{abacusai-0.52.1 → abacusai-0.61.0}/abacusai/api_class/__init__.py

@@ -1,2 +1,3 @@
 from .dataset import *
 from .feature_group import *
+from .model import *

abacusai-0.61.0/abacusai/api_class/abstract.py

@@ -0,0 +1,106 @@
+import dataclasses
+import datetime
+import inspect
+import re
+from abc import ABC
+
+from .enums import ApiEnum
+
+
+FIRST_CAP_RE = re.compile('(.)([A-Z][a-z]+)')
+ALL_CAP_RE = re.compile('([a-z0-9])([A-Z])')
+
+
+def camel_case(value):
+    if value:
+        components = value.split('_')
+        return components[0] + ''.join(x.title() for x in components[1:])
+    return value
+
+
+def upper_snake_case(value):
+    if value:
+        s1 = FIRST_CAP_RE.sub(r'\1_\2', value)
+        return ALL_CAP_RE.sub(r'\1_\2', s1).upper()
+    return value
+
+
+def snake_case(value):
+    if value:
+        s1 = FIRST_CAP_RE.sub(r'\1_\2', value)
+        return ALL_CAP_RE.sub(r'\1_\2', s1).lower()
+    return value
+
+
+@dataclasses.dataclass
+class ApiClass(ABC):
+    _upper_snake_case_keys: bool = dataclasses.field(default=False, repr=False, init=False)
+    _support_kwargs: bool = dataclasses.field(default=False, repr=False, init=False)
+
+    def __post_init__(self):
+        if inspect.isabstract(self):
+            raise ValueError(f'Cannot instantiate abstract class {self.__class__.__name__}')
+
+    def to_dict(self):
+        """
+        Standardizes converting an ApiClass to dictionary.
+        Keys of response dictionary are converted to camel case.
+        This also validates the fields ( type, value, etc ) received in the dictionary.
+        """
+        def to_dict_helper(api_class_obj):
+            res = {}
+            api_class_dict = vars(api_class_obj)
+            if self._support_kwargs:
+                kwargs = api_class_dict.pop('kwargs', None)
+                api_class_dict.update(kwargs or {})
+            for k, v in api_class_dict.items():
+                if not k.startswith('__'):
+                    k = upper_snake_case(k) if self._upper_snake_case_keys else camel_case(k)
+                if v is not None:
+                    if isinstance(v, ApiClass):
+                        res[k] = to_dict_helper(v)
+                    elif isinstance(v, list):
+                        res[k] = [to_dict_helper(val) if isinstance(val, ApiClass) else val for val in v]
+                    elif isinstance(v, dict):
+                        res[k] = {key: to_dict_helper(val) if isinstance(val, ApiClass) else val for key, val in v.items()}
+                    elif isinstance(v, datetime.datetime) or isinstance(v, datetime.date):
+                        res[k] = v.isoformat() if v else v
+                    else:
+                        if isinstance(v, ApiEnum):
+                            res[k] = v.value
+                        else:
+                            res[k] = v
+            return res
+
+        return to_dict_helper(self)
+
+    @classmethod
+    def from_dict(cls, input_dict: 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)
+
+
+@dataclasses.dataclass
+class _ApiClassFactory(ABC):
+    config_abstract_class = None
+    config_class_key = None
+    config_class_map = {}
+
+    @classmethod
+    def from_dict(cls, config: dict) -> ApiClass:
+        support_kwargs = cls.config_abstract_class and cls.config_abstract_class._support_kwargs
+        config_class_key = cls.config_class_key if (cls.config_abstract_class and not cls.config_abstract_class._upper_snake_case_keys) else camel_case(cls.config_class_key)
+        if not support_kwargs and config_class_key not in (config or {}):
+            raise KeyError(f'Could not find {config_class_key} in {config}')
+        config_class_type = config.get(config_class_key, None)
+        if isinstance(config_class_type, str):
+            config_class_type = config_class_type.upper()
+        config_class = cls.config_class_map.get(config_class_type)
+        if config_class is None and support_kwargs:
+            config = {'kwargs': config}
+            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)

abacusai-0.61.0/abacusai/api_class/enums.py

@@ -0,0 +1,158 @@
+from enum import Enum
+
+
+class ApiEnum(Enum):
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.value.upper() == other.upper()
+        elif isinstance(other, int):
+            return self.value == other
+        elif other is None:
+            return self.value == ''
+        return super().__eq__(other)
+
+    def __hash__(self):
+        if isinstance(self.value, str):
+            return hash(self.value.upper())
+        return hash(self.value)
+
+
+class ProblemType(ApiEnum):
+    USER_ITEM_SCORING = 'affinity'
+    ANOMALY_DETECTION = 'anomaly_new'
+    ANOMALY_OUTLIERS = 'anomaly'
+    CLUSTERING = 'clustering'
+    CLUSTERING_TIMESERIES = 'clustering_timeseries'
+    CUMULATIVE_FORECASTING = 'cumulative_forecasting'
+    NAMED_ENTITY_EXTRACTION = 'nlp_ner'
+    NATURAL_LANGUAGE_SEARCH = 'nlp_search'
+    SENTENCE_BOUNDARY_DETECTION = 'nlp_sentence_boundary_detection'
+    SENTIMENT_DETECTION = 'nlp_sentiment'
+    DOCUMENT_CLASSIFICATION = 'nlp_classification'
+    DOCUMENT_SUMMARIZATION = 'nlp_summarization'
+    DOCUMENT_VISUALIZATION = 'nlp_document_visualization'
+    PERSONALIZATION = 'personalization'
+    PREDICTIVE_MODELING = 'regression'
+    FORECASTING = 'forecasting'
+    CUSTOM_TRAINED_MODEL = 'plug_and_play'
+    FEATURE_STORE = 'feature_store'
+    IMAGE_CLASSIFICATION = 'vision_classification'
+    OBJECT_DETECTION = 'vision_object_detection'
+    IMAGE_VALUE_PREDICTION = 'vision_regression'
+    MODEL_MONITORING = 'model_monitoring'
+    LANGUAGE_DETECTION = 'language_detection'
+    OPTIMIZATION = 'optimization'
+    PRETRAINED_MODELS = 'pretrained'
+    THEME_ANALYSIS = 'theme_analysis'
+
+
+class SamplingMethodType(ApiEnum):
+    N_SAMPLING = 'N_SAMPLING'
+    PERCENT_SAMPLING = 'PERCENT_SAMPLING'
+
+
+class FillLogic(ApiEnum):
+    # back / future
+    AVERAGE = 'average'
+    MAX = 'max'
+    MEDIAN = 'median'
+    MIN = 'min'
+    CUSTOM = 'custom'
+    # middle
+    BACKFILL = 'bfill'
+    FORWARDFILL = 'ffill'
+    LINEAR = 'linear'
+    NEAREST = 'nearest'
+
+
+class BatchSize(ApiEnum):
+    BATCH_8 = 8
+    BATCH_16 = 16
+    BATCH_32 = 32
+    BATCH_64 = 64
+    BATCH_128 = 128
+    BATCH_256 = 256
+    BATCH_384 = 384
+    BATCH_512 = 512
+    BATCH_740 = 740
+    BATCH_1024 = 1024
+
+
+class HolidayCalendars(ApiEnum):
+    AU = 'AU'
+    UK = 'UK'
+    US = 'US'
+
+
+# Forecasting
+class ForecastingObjective(ApiEnum):
+    ACCURACY = 'w_c_accuracy'
+    WAPE = 'wape'
+    MAPE = 'mape'
+    CMAPE = 'cmape'
+    RMSE = 'rmse'
+    CV = 'coefficient_of_variation'
+    BIAS = 'bias'
+    SRMSE = 'srmse'
+
+
+class ForecastingFrequency(ApiEnum):
+    HOURLY = '1H'
+    DAILY = '1D'
+    WEEKLY_SUNDAY_START = '1W'
+    WEEKLY_MONDAY_START = 'W-MON'
+    WEEKLY_SATURDAY_START = 'W-SAT'
+    MONTH_START = 'MS'
+    MONTH_END = '1M'
+    QUARTER_START = 'QS'
+    QUARTER_END = '1Q'
+    YEARLY = '1Y'
+
+
+class ForecastingDataSplitType(ApiEnum):
+    AUTO = 'Automatic Time Based'
+    TIMESTAMP = 'Timestamp Based'
+    ITEM = 'Item Based'
+    PREDICTION_LENGTH = 'Force Prediction Length'
+
+
+class ForecastingLossFunction(ApiEnum):
+    CUSTOM = 'Custom'
+    MEAN_ABSOLUTE_ERROR = 'mae'
+    NORMALIZED_MEAN_ABSOLUTE_ERROR = 'nmae'
+    PEAKS_MEAN_ABSOLUTE_ERROR = 'peaks_mae'
+    MEAN_ABSOLUTE_PERCENTAGE_ERROR = 'stable_mape'
+    POINTWISE_ACCURACY = 'accuracy'
+    ROOT_MEAN_SQUARE_ERROR = 'rmse'
+    NORMALIZED_ROOT_MEAN_SQUARE_ERROR = 'nrmse'
+    ASYMMETRIC_MEAN_ABSOLUTE_PERCENTAGE_ERROR = 'asymmetric_mape'
+    STABLE_STANDARDIZED_MEAN_ABSOLUTE_PERCENTAGE_ERROR = 'stable_standardized_mape_with_cmape'
+    GAUSSIAN = 'mle_gaussian_local'
+    GAUSSIAN_FULL_COVARIANCE = 'mle_gaussfullcov'
+    GUASSIAN_EXPONENTIAL = 'mle_gaussexp'
+    MIX_GAUSSIANS = 'mle_gaussmix'
+    WEIBULL = 'mle_weibull'
+    NEGATIVE_BINOMIAL = 'mle_negbinom'
+    LOG_ROOT_MEAN_SQUARE_ERROR = 'log_rmse'
+
+
+class ForecastingLocalScaling(ApiEnum):
+    ZSCORE = 'zscore'
+    SLIDING_ZSCORE = 'sliding_zscore'
+    LAST_POINT = 'lastpoint'
+    MIN_MAX = 'minmax'
+    MIN_STD = 'minstd'
+    ROBUST = 'robust'
+    ITEM = 'item'
+
+
+class ForecastingFillMethod(ApiEnum):
+    BACK = 'BACK'
+    MIDDLE = 'MIDDLE'
+    FUTURE = 'FUTURE'
+
+
+class ForecastingQuanitlesExtensionMethod(ApiEnum):
+    DIRECT = 'direct'
+    QUADRATIC = 'quadratic'
+    ANCESTRAL_SIMULATION = 'simulation'

{abacusai-0.52.1 → abacusai-0.61.0}/abacusai/api_class/feature_group.py

@@ -26,8 +26,8 @@ class NSamplingConfig(SamplingConfig):
         key_columns (list[str]): The feature(s) to use as the key(s) when sampling
     """
     sample_count: int
-    sampling_method: enums.SamplingMethodType = dataclasses.field(default=enums.SamplingMethodType.N_SAMPLING)
     key_columns: List[str] = dataclasses.field(default_factory=list)
+    sampling_method: enums.SamplingMethodType = enums.SamplingMethodType.N_SAMPLING
 
 
 @dataclasses.dataclass
@@ -41,8 +41,8 @@ class PercentSamplingConfig(SamplingConfig):
         key_columns (list[str]): The feature(s) to use as the key(s) when sampling
     """
     sample_percent: float
-    sampling_method: enums.SamplingMethodType = dataclasses.field(default=enums.SamplingMethodType.PERCENT_SAMPLING)
     key_columns: List[str] = dataclasses.field(default_factory=list)
+    sampling_method: enums.SamplingMethodType = enums.SamplingMethodType.PERCENT_SAMPLING
 
 
 @dataclasses.dataclass

abacusai-0.61.0/abacusai/api_class/model.py

@@ -0,0 +1,156 @@
+import dataclasses
+from datetime import datetime
+from typing import List
+
+from . import enums
+from .abstract import ApiClass, _ApiClassFactory
+
+
+@dataclasses.dataclass
+class TrainingConfig(ApiClass):
+    _upper_snake_case_keys: bool = dataclasses.field(default=True, repr=False, init=False)
+    _support_kwargs: bool = dataclasses.field(default=True, repr=False, init=False)
+
+    kwargs: dict = dataclasses.field(default_factory=dict)
+    problem_type: enums.ProblemType = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class ForecastingTrainingConfig(TrainingConfig):
+    """
+    Training config for the FORECASTING problem type
+    Args:
+        problem_type (ProblemType): FORECASTING
+        prediction_length (int): How many timesteps in the future to predict.
+        objective (ForecastingObjective): Ranking scheme used to select final best model.
+        sort_objective (ForecastingObjective): Ranking scheme used to sort models on the metrics page.
+        forecast_frequency (ForecastingFrequency): Forecast frequency.
+        probability_quantiles (list[float]): Prediction quantiles.
+        no_validation_set (bool): Do not generate validation set, test set will be used instead.
+        force_prediction_length (int): Force length of test window to be the same as prediction length.
+        filter_items (bool): Filter items with small history and volume.
+        enable_cold_start (bool): Enable cold start forecasting by training/predicting for zero history items.
+        enable_multiple_backtests (bool): Whether to enable multiple backtesting or not.
+        total_backtesting_windows (int): Total backtesting windows to use for the training.
+        backtest_window_step_size (int): Use this step size to shift backtesting windows for model training.
+        full_data_retraining (bool): Train models separately with all the data.
+        type_of_split (ForecastingDataSplitType): Type of data splitting into train/test.
+        test_by_item (bool): Partition train/test data by item rather than time if true.
+        test_start (datetime): Limit training data to dates before the given test start.
+        test_split (int): Percent of dataset to use for test data. We support using a range between 5% to 20% of your dataset to use as test data.
+        loss_function (ForecastingLossFunction): Loss function for training neural network.
+        underprediction_weight (float): Weight for underpredictions
+        disable_networks_without_analytic_quantiles (bool): Disable neural networks, which quantile functions do not have analytic expressions (e.g, mixture models)
+        initial_learning_rate (float): Initial learning rate.
+        l2_regularization_factor (float): L2 regularization factor.
+        dropout_rate (int): Dropout percentage rate.
+        recurrent_layers (int): Number of recurrent layers to stack in network.
+        recurrent_units (int): Number of units in each recurrent layer.
+        convolutional_layers (int): Number of convolutional layers to stack on top of recurrent layers in network.
+        convolution_filters (int): Number of filters in each convolution.
+        local_scaling_mode (ForecastingLocalScaling): Options to make NN inputs stationary in high dynamic range datasets.
+        zero_predictor (bool): Include subnetwork to classify points where target equals zero.
+        skip_missing (bool): Make the RNN ignore missing entries rather instead of processing them.
+        batch_size (ForecastingBatchSize): Batch size.
+        batch_renormalization (bool): Enable batch renormalization between layers.
+        history_length (int): While training, how much history to consider.
+        prediction_step_size (int): Number of future periods to include in objective for each training sample.
+        training_point_overlap (float): Amount of overlap to allow between training samples.
+        max_scale_context (int): Maximum context to use for local scaling.
+        quantiles_extension_method (ForecastingQuanitlesExtensionMethod): Quantile extension method
+        number_of_samples (int): Number of samples for ancestral simulation
+        symmetrize_quantiles (bool): Force symmetric quantiles (like in Gaussian distribution)
+        use_log_transforms (bool): Apply logarithmic transformations to input data.
+        smooth_history (float): Smooth (low pass filter) the timeseries.
+        prediction_offset (int): Offset for prediction.
+        skip_local_scale_target (bool): Skip using per training/prediction window target scaling.
+        timeseries_weight_column (str): If set, we use the values in this column from timeseries data to assign time dependent item weights during training and evaluation.
+        item_attributes_weight_column (str): If set, we use the values in this column from item attributes data to assign weights to items during training and evaluation.
+        use_timeseries_weights_in_objective (bool): If True, we include weights from column set as "TIMESERIES WEIGHT COLUMN" in objective functions.
+        use_item_weights_in_objective (bool): If True, we include weights from column set as "ITEM ATTRIBUTES WEIGHT COLUMN" in objective functions.
+        skip_timeseries_weight_scaling (bool): If True, we will avoid normalizing the weights.
+        timeseries_loss_weight_column (str): Use value in this column to weight the loss while training.
+        use_item_id (bool): Include a feature to indicate the item being forecast.
+        use_all_item_totals (bool): Include as input total target across items.
+        handle_zeros_as_missing (bool): If True, handle zero values in demand as missing data.
+        datetime_holiday_calendars (list[HolidayCalendars]): Holiday calendars to augment training with.
+        fill_missing_values (list[dict]): Strategy for filling in missing values.
+        enable_clustering (bool): Enable clustering in forecasting.
+        data_split_feature_group_table_name (str): Specify the table name of the feature group to export training data with the fold column.
+        custom_loss_functions (list[str]): Registered custom losses available for selection.
+        custom_metrics (list[str]): Registered custom metrics available for selection.
+    """
+    problem_type: enums.ProblemType = dataclasses.field(default=enums.ProblemType.FORECASTING, repr=False, init=False)
+    prediction_length: int = dataclasses.field(default=None)
+    objective: enums.ForecastingObjective = dataclasses.field(default=None)
+    sort_objective: enums.ForecastingObjective = dataclasses.field(default=None)
+    forecast_frequency: enums.ForecastingFrequency = dataclasses.field(default=None)
+    probability_quantiles: List[float] = dataclasses.field(default=None)
+    no_validation_set: bool = dataclasses.field(default=None)
+    force_prediction_length: bool = dataclasses.field(default=None)
+    filter_items: bool = dataclasses.field(default=None)
+    enable_cold_start: bool = dataclasses.field(default=None)
+    enable_multiple_backtests: bool = dataclasses.field(default=None)
+    total_backtesting_windows: int = dataclasses.field(default=None)
+    backtest_window_step_size: int = dataclasses.field(default=None)
+    full_data_retraining: bool = dataclasses.field(default=None)
+    # Data split params
+    type_of_split: enums.ForecastingDataSplitType = dataclasses.field(default=enums.ForecastingDataSplitType.AUTO)
+    test_by_item: bool = dataclasses.field(default=None)
+    test_start: datetime = dataclasses.field(default=None)
+    test_split: int = dataclasses.field(default=None)
+    # Neural network
+    loss_function: enums.ForecastingLossFunction = dataclasses.field(default=None)
+    underprediction_weight: float = dataclasses.field(default=None)
+    disable_networks_without_analytic_quantiles: bool = dataclasses.field(default=None)
+    initial_learning_rate: float = dataclasses.field(default=None)
+    l2_regularization_factor: float = dataclasses.field(default=None)
+    dropout_rate: int = dataclasses.field(default=None)
+    recurrent_layers: int = dataclasses.field(default=None)
+    recurrent_units: int = dataclasses.field(default=None)
+    convolutional_layers: int = dataclasses.field(default=None)
+    convolution_filters: int = dataclasses.field(default=None)
+    local_scaling_mode: enums.ForecastingLocalScaling = dataclasses.field(default=None)
+    zero_predictor: bool = dataclasses.field(default=None)
+    skip_missing: bool = dataclasses.field(default=None)
+    batch_size: enums.BatchSize = dataclasses.field(default=None)
+    batch_renormalization: bool = dataclasses.field(default=None)
+    # Timeseries
+    history_length: int = dataclasses.field(default=None)
+    prediction_step_size: int = dataclasses.field(default=None)
+    training_point_overlap: float = dataclasses.field(default=None)
+    max_scale_context: int = dataclasses.field(default=None)
+    quantiles_extension_method: enums.ForecastingQuanitlesExtensionMethod = dataclasses.field(default=None)
+    number_of_samples: int = dataclasses.field(default=None)
+    symmetrize_quantiles: bool = dataclasses.field(default=None)
+    use_log_transforms: bool = dataclasses.field(default=None)
+    smooth_history: float = dataclasses.field(default=None)
+    prediction_offset: int = dataclasses.field(default=None)
+    skip_local_scale_target: bool = dataclasses.field(default=None)
+    # Item weights
+    timeseries_weight_column: str = dataclasses.field(default=None)
+    item_attributes_weight_column: str = dataclasses.field(default=None)
+    use_timeseries_weights_in_objective: bool = dataclasses.field(default=None)
+    use_item_weights_in_objective: bool = dataclasses.field(default=None)
+    skip_timeseries_weight_scaling: bool = dataclasses.field(default=None)
+    timeseries_loss_weight_column: str = dataclasses.field(default=None)
+    # Data Augmentation
+    use_item_id: bool = dataclasses.field(default=None)
+    use_all_item_totals: bool = dataclasses.field(default=None)
+    handle_zeros_as_missing: bool = dataclasses.field(default=None)
+    datetime_holiday_calendars: List[enums.HolidayCalendars] = dataclasses.field(default=None)
+    fill_missing_values: List[dict] = dataclasses.field(default=None)
+    enable_clustering: bool = dataclasses.field(default=None)
+    # Others
+    data_split_feature_group_table_name: str = dataclasses.field(default=None)
+    custom_loss_functions: List[str] = dataclasses.field(default=None)
+    custom_metrics: List[str] = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class _TrainingConfigFactory(_ApiClassFactory):
+    config_abstract_class = TrainingConfig
+    config_class_key = 'problem_type'
+    config_class_map = {
+        enums.ProblemType.FORECASTING: ForecastingTrainingConfig
+    }

abacusai-0.61.0/abacusai/api_endpoint.py

@@ -0,0 +1,29 @@
+from .return_class import AbstractApiClass
+
+
+class ApiEndpoint(AbstractApiClass):
+    """
+        An collection of endpoints which can be used to make requests to, such as api calls or predict calls
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            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
+    """
+
+    def __init__(self, client, apiEndpoint=None, predictEndpoint=None):
+        super().__init__(client, None)
+        self.api_endpoint = apiEndpoint
+        self.predict_endpoint = predictEndpoint
+
+    def __repr__(self):
+        return f"ApiEndpoint(api_endpoint={repr(self.api_endpoint)},\n  predict_endpoint={repr(self.predict_endpoint)})"
+
+    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 {'api_endpoint': self.api_endpoint, 'predict_endpoint': self.predict_endpoint}

abacusai-0.61.0/abacusai/chat_bot_response.py

@@ -0,0 +1,29 @@
+from .return_class import AbstractApiClass
+
+
+class ChatBotResponse(AbstractApiClass):
+    """
+        A response from the chat bot
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            answer (str): The response from the chat bot
+            chatHistory (list): The chat history as a list of dicts with is_user and text entries
+    """
+
+    def __init__(self, client, answer=None, chatHistory=None):
+        super().__init__(client, None)
+        self.answer = answer
+        self.chat_history = chatHistory
+
+    def __repr__(self):
+        return f"ChatBotResponse(answer={repr(self.answer)},\n  chat_history={repr(self.chat_history)})"
+
+    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 {'answer': self.answer, 'chat_history': self.chat_history}