oracle-ads 2.13.2__py3-none-any.whl → 2.13.2rc1__py3-none-any.whl

ads/opctl/operator/lowcode/forecast/model_evaluator.py

@@ -1,20 +1,21 @@
-# -*- coding: utf-8; -*-
-
 # Copyright (c) 2023 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 
+from pathlib import Path
+
 import numpy as np
 import pandas as pd
-from pathlib import Path
 
 from ads.opctl import logger
 from ads.opctl.operator.lowcode.common.const import DataColumns
+from ads.opctl.operator.lowcode.common.errors import InsufficientDataError
 from ads.opctl.operator.lowcode.forecast.const import BACKTEST_REPORT_NAME
+from ads.opctl.operator.lowcode.forecast.model.factory import SupportedModels
+
 from .model.forecast_datasets import ForecastDatasets
 from .operator_config import ForecastOperatorConfig
-from ads.opctl.operator.lowcode.forecast.model.factory import SupportedModels
-from ads.opctl.operator.lowcode.common.errors import InsufficientDataError
+
 
 class ModelEvaluator:
     """
@@ -23,6 +24,7 @@ class ModelEvaluator:
     This class is responsible for comparing different models or frameworks based on specified evaluation
     metrics and returning the best-performing option.
     """
+
     def __init__(self, models, k=5, subsample_ratio=0.20):
         """
         Initializes the ModelEvaluator with a list of models, number of backtests and subsample ratio.
@@ -40,23 +42,33 @@ class ModelEvaluator:
 
     def generate_cutoffs(self, unique_dates, horizon):
         sorted_dates = np.sort(unique_dates)
-        train_window_size = [len(sorted_dates) - (i + 1) * horizon for i in range(self.k)]
+        train_window_size = [
+            len(sorted_dates) - (i + 1) * horizon for i in range(self.k)
+        ]
         valid_train_window_size = [ws for ws in train_window_size if ws >= horizon * 2]
         if len(valid_train_window_size) < self.k:
-            logger.warn(f"Only {valid_train_window_size} backtests can be created")
-        cut_offs = sorted_dates[-horizon - 1:-horizon * (self.k + 1):-horizon][:len(valid_train_window_size)]
+            logger.warning(f"Only {valid_train_window_size} backtests can be created")
+        cut_offs = sorted_dates[-horizon - 1 : -horizon * (self.k + 1) : -horizon][
+            : len(valid_train_window_size)
+        ]
         return cut_offs
 
-    def generate_k_fold_data(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
+    def generate_k_fold_data(
+        self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig
+    ):
         date_col = operator_config.spec.datetime_column.name
         horizon = operator_config.spec.horizon
         historical_data = datasets.historical_data.data.reset_index()
         series_col = DataColumns.Series
         group_counts = historical_data[series_col].value_counts()
 
-        sample_count = max(self.minimum_sample_count, int(len(group_counts) * self.subsample_ratio))
+        sample_count = max(
+            self.minimum_sample_count, int(len(group_counts) * self.subsample_ratio)
+        )
         sampled_groups = group_counts.head(sample_count)
-        sampled_historical_data = historical_data[historical_data[series_col].isin(sampled_groups.index)]
+        sampled_historical_data = historical_data[
+            historical_data[series_col].isin(sampled_groups.index)
+        ]
 
         min_group = group_counts.idxmin()
         min_series_data = historical_data[historical_data[series_col] == min_group]
@@ -64,32 +76,62 @@ class ModelEvaluator:
 
         cut_offs = self.generate_cutoffs(unique_dates, horizon)
         if not len(cut_offs):
-            raise InsufficientDataError("Insufficient data to evaluate multiple models. Please specify a model "
-                                        "instead of using auto-select.")
-        training_datasets = [sampled_historical_data[sampled_historical_data[date_col] <= cut_off_date] for cut_off_date
-                             in cut_offs]
-        test_datasets = [sampled_historical_data[sampled_historical_data[date_col] > cut_offs[0]]]
+            raise InsufficientDataError(
+                "Insufficient data to evaluate multiple models. Please specify a model "
+                "instead of using auto-select."
+            )
+        training_datasets = [
+            sampled_historical_data[sampled_historical_data[date_col] <= cut_off_date]
+            for cut_off_date in cut_offs
+        ]
+        test_datasets = [
+            sampled_historical_data[sampled_historical_data[date_col] > cut_offs[0]]
+        ]
         for i, current in enumerate(cut_offs[1:]):
-            test_datasets.append(sampled_historical_data[(current < sampled_historical_data[date_col]) & (
-                    sampled_historical_data[date_col] <= cut_offs[i])])
+            test_datasets.append(
+                sampled_historical_data[
+                    (current < sampled_historical_data[date_col])
+                    & (sampled_historical_data[date_col] <= cut_offs[i])
+                ]
+            )
         all_additional = datasets.additional_data.data.reset_index()
-        sampled_additional_data = all_additional[all_additional[series_col].isin(sampled_groups.index)]
+        sampled_additional_data = all_additional[
+            all_additional[series_col].isin(sampled_groups.index)
+        ]
         max_historical_date = sampled_historical_data[date_col].max()
-        additional_data = [sampled_additional_data[sampled_additional_data[date_col] <= max_historical_date]]
+        additional_data = [
+            sampled_additional_data[
+                sampled_additional_data[date_col] <= max_historical_date
+            ]
+        ]
         for cut_off in cut_offs[:-1]:
-            trimmed_additional_data = sampled_additional_data[sampled_additional_data[date_col] <= cut_off]
+            trimmed_additional_data = sampled_additional_data[
+                sampled_additional_data[date_col] <= cut_off
+            ]
             additional_data.append(trimmed_additional_data)
         return cut_offs, training_datasets, additional_data, test_datasets
 
     def remove_none_values(self, obj):
         if isinstance(obj, dict):
-            return {k: self.remove_none_values(v) for k, v in obj.items() if k is not None and v is not None}
+            return {
+                k: self.remove_none_values(v)
+                for k, v in obj.items()
+                if k is not None and v is not None
+            }
         else:
             return obj
 
-    def create_operator_config(self, operator_config, backtest, model, historical_data, additional_data, test_data):
+    def create_operator_config(
+        self,
+        operator_config,
+        backtest,
+        model,
+        historical_data,
+        additional_data,
+        test_data,
+    ):
         output_dir = operator_config.spec.output_directory.url
-        output_file_path = f'{output_dir}/back_testing/{model}/{backtest}'
+        output_file_path = f"{output_dir}/back_testing/{model}/{backtest}"
         Path(output_file_path).mkdir(parents=True, exist_ok=True)
         backtest_op_config_draft = operator_config.to_dict()
         backtest_spec = backtest_op_config_draft["spec"]
@@ -99,62 +141,102 @@ class ModelEvaluator:
         backtest_spec.pop("historical_data")
         backtest_spec["generate_report"] = False
         backtest_spec["model"] = model
-        backtest_spec['model_kwargs'] = None
+        backtest_spec["model_kwargs"] = None
         backtest_spec["output_directory"] = {"url": output_file_path}
         backtest_spec["target_category_columns"] = [DataColumns.Series]
-        backtest_spec['generate_explanations'] = False
+        backtest_spec["generate_explanations"] = False
         cleaned_config = self.remove_none_values(backtest_op_config_draft)
 
-        backtest_op_config = ForecastOperatorConfig.from_dict(
-            obj_dict=cleaned_config)
+        backtest_op_config = ForecastOperatorConfig.from_dict(obj_dict=cleaned_config)
         return backtest_op_config
 
-    def run_all_models(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
-        cut_offs, train_sets, additional_data, test_sets = self.generate_k_fold_data(datasets, operator_config)
+    def run_all_models(
+        self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig
+    ):
+        cut_offs, train_sets, additional_data, test_sets = self.generate_k_fold_data(
+            datasets, operator_config
+        )
         metrics = {}
         date_col = operator_config.spec.datetime_column.name
         for model in self.models:
             from .model.factory import ForecastOperatorModelFactory
+
             metrics[model] = {}
             for i in range(len(cut_offs)):
                 try:
-                    backtest_historical_data = train_sets[i].set_index([date_col, DataColumns.Series])
-                    backtest_additional_data = additional_data[i].set_index([date_col, DataColumns.Series])
-                    backtest_test_data = test_sets[i].set_index([date_col, DataColumns.Series])
-                    backtest_operator_config = self.create_operator_config(operator_config, i, model,
-                                                                           backtest_historical_data,
-                                                                           backtest_additional_data,
-                                                                           backtest_test_data)
-                    datasets = ForecastDatasets(backtest_operator_config,
-                                                backtest_historical_data,
-                                                backtest_additional_data,
-                                                backtest_test_data)
+                    backtest_historical_data = train_sets[i].set_index(
+                        [date_col, DataColumns.Series]
+                    )
+                    backtest_additional_data = additional_data[i].set_index(
+                        [date_col, DataColumns.Series]
+                    )
+                    backtest_test_data = test_sets[i].set_index(
+                        [date_col, DataColumns.Series]
+                    )
+                    backtest_operator_config = self.create_operator_config(
+                        operator_config,
+                        i,
+                        model,
+                        backtest_historical_data,
+                        backtest_additional_data,
+                        backtest_test_data,
+                    )
+                    datasets = ForecastDatasets(
+                        backtest_operator_config,
+                        backtest_historical_data,
+                        backtest_additional_data,
+                        backtest_test_data,
+                    )
                     ForecastOperatorModelFactory.get_model(
                         backtest_operator_config, datasets
                     ).generate_report()
-                    test_metrics_filename = backtest_operator_config.spec.test_metrics_filename
+                    test_metrics_filename = (
+                        backtest_operator_config.spec.test_metrics_filename
+                    )
                     metrics_df = pd.read_csv(
-                        f"{backtest_operator_config.spec.output_directory.url}/{test_metrics_filename}")
-                    metrics_df["average_across_series"] = metrics_df.drop('metrics', axis=1).mean(axis=1)
-                    metrics_average_dict = dict(zip(metrics_df['metrics'].str.lower(), metrics_df['average_across_series']))
-                    metrics[model][i] = metrics_average_dict[operator_config.spec.metric]
+                        f"{backtest_operator_config.spec.output_directory.url}/{test_metrics_filename}"
+                    )
+                    metrics_df["average_across_series"] = metrics_df.drop(
+                        "metrics", axis=1
+                    ).mean(axis=1)
+                    metrics_average_dict = dict(
+                        zip(
+                            metrics_df["metrics"].str.lower(),
+                            metrics_df["average_across_series"],
+                        )
+                    )
+                    metrics[model][i] = metrics_average_dict[
+                        operator_config.spec.metric
+                    ]
                 except:
-                    logger.warn(f"Failed to calculate metrics for {model} and {i} backtest")
+                    logger.warning(
+                        f"Failed to calculate metrics for {model} and {i} backtest"
+                    )
         return metrics
 
-    def find_best_model(self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig):
+    def find_best_model(
+        self, datasets: ForecastDatasets, operator_config: ForecastOperatorConfig
+    ):
         try:
             metrics = self.run_all_models(datasets, operator_config)
         except InsufficientDataError as e:
             model = SupportedModels.Prophet
-            logger.error(f"Running {model} model as auto-select failed with the following error: {e.message}")
+            logger.error(
+                f"Running {model} model as auto-select failed with the following error: {e.message}"
+            )
             return model
-        nonempty_metrics = {model: metric for model, metric in metrics.items() if metric != {}}
-        avg_backtests_metric = {model: sum(value.values()) / len(value.values())
-                                for model, value in nonempty_metrics.items()}
+        nonempty_metrics = {
+            model: metric for model, metric in metrics.items() if metric != {}
+        }
+        avg_backtests_metric = {
+            model: sum(value.values()) / len(value.values())
+            for model, value in nonempty_metrics.items()
+        }
         best_model = min(avg_backtests_metric, key=avg_backtests_metric.get)
-        logger.info(f"Among models {self.models}, {best_model} model shows better performance during backtesting.")
-        backtest_stats = pd.DataFrame(nonempty_metrics).rename_axis('backtest')
+        logger.info(
+            f"Among models {self.models}, {best_model} model shows better performance during backtesting."
+        )
+        backtest_stats = pd.DataFrame(nonempty_metrics).rename_axis("backtest")
         backtest_stats["metric"] = operator_config.spec.metric
         backtest_stats.reset_index(inplace=True)
         output_dir = operator_config.spec.output_directory.url

ads/opctl/operator/lowcode/forecast/operator_config.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2023, 2024 Oracle and/or its affiliates.
+# Copyright (c) 2023, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import os
@@ -18,9 +18,11 @@ from ads.opctl.operator.lowcode.common.utils import find_output_dirname
 
 from .const import SpeedAccuracyMode, SupportedMetrics, SupportedModels
 
+
 @dataclass
 class AutoScaling(DataClassSerializable):
     """Class representing simple autoscaling policy"""
+
     minimum_instance: int = 1
     maximum_instance: int = None
     cool_down_in_seconds: int = 600
@@ -28,9 +30,11 @@ class AutoScaling(DataClassSerializable):
     scale_out_threshold: int = 80
     scaling_metric: str = "CPU_UTILIZATION"
 
+
 @dataclass(repr=True)
 class ModelDeploymentServer(DataClassSerializable):
     """Class representing model deployment server specification for whatif-analysis."""
+
     display_name: str = None
     initial_shape: str = None
     description: str = None
@@ -42,10 +46,13 @@ class ModelDeploymentServer(DataClassSerializable):
 @dataclass(repr=True)
 class WhatIfAnalysis(DataClassSerializable):
     """Class representing operator specification for whatif-analysis."""
+
     model_display_name: str = None
     compartment_id: str = None
     project_id: str = None
-    model_deployment: ModelDeploymentServer = field(default_factory=ModelDeploymentServer)
+    model_deployment: ModelDeploymentServer = field(
+        default_factory=ModelDeploymentServer
+    )
 
 
 @dataclass(repr=True)
@@ -106,8 +113,11 @@ class ForecastOperatorSpec(DataClassSerializable):
     datetime_column: DateTimeColumn = field(default_factory=DateTimeColumn)
     target_category_columns: List[str] = field(default_factory=list)
     generate_report: bool = None
+    generate_forecast_file: bool = None
     generate_metrics: bool = None
+    generate_metrics_file: bool = None
     generate_explanations: bool = None
+    generate_explanation_files: bool = None
     explanations_accuracy_mode: str = None
     horizon: int = None
     model: str = None
@@ -126,7 +136,7 @@ class ForecastOperatorSpec(DataClassSerializable):
         self.output_directory = self.output_directory or OutputDirectory(
             url=find_output_dirname(self.output_directory)
         )
-        self.generate_model_pickle = True if self.generate_model_pickle or self.what_if_analysis else False
+        self.generate_model_pickle = self.generate_model_pickle or self.what_if_analysis
         self.metric = (self.metric or "").lower() or SupportedMetrics.SMAPE.lower()
         self.model = self.model or SupportedModels.Prophet
         self.confidence_interval_width = self.confidence_interval_width or 0.80
@@ -144,6 +154,21 @@ class ForecastOperatorSpec(DataClassSerializable):
         self.generate_metrics = (
             self.generate_metrics if self.generate_metrics is not None else True
         )
+        self.generate_metrics_file = (
+            self.generate_metrics_file
+            if self.generate_metrics_file is not None
+            else True
+        )
+        self.generate_forecast_file = (
+            self.generate_forecast_file
+            if self.generate_forecast_file is not None
+            else True
+        )
+        self.generate_explanation_files = (
+            self.generate_explanation_files
+            if self.generate_explanation_files is not None
+            else True
+        )
         # For Explanations Generation. When user doesn't specify defaults to False
         self.generate_explanations = (
             self.generate_explanations
@@ -164,6 +189,7 @@ class ForecastOperatorSpec(DataClassSerializable):
             if self.generate_model_pickle is not None
             else False
         )
+        self.report_title = self.report_title or "Forecast Report"
         self.report_theme = self.report_theme or "light"
         self.metrics_filename = self.metrics_filename or "metrics.csv"
         self.test_metrics_filename = self.test_metrics_filename or "test_metrics.csv"

ads/opctl/operator/lowcode/forecast/whatifserve/deployment_manager.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-import json
 # Copyright (c) 2023, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
@@ -8,39 +7,58 @@ import pickle
 import shutil
 import sys
 import tempfile
-import oci
 
-import pandas as pd
 import cloudpickle
+import oci
+import pandas as pd
+from oci.data_science import DataScienceClient, DataScienceClientCompositeOperations
+from oci.data_science.models import (
+    CategoryLogDetails,
+    CreateModelDeploymentDetails,
+    FixedSizeScalingPolicy,
+    InstanceConfiguration,
+    LogDetails,
+    ModelConfigurationDetails,
+    SingleModelDeploymentConfigurationDetails,
+)
 
-from ads.opctl import logger
 from ads.common.model_export_util import prepare_generic_model
+from ads.common.object_storage_details import ObjectStorageDetails
+from ads.opctl import logger
 from ads.opctl.operator.common.utils import create_log_in_log_group
-from ads.opctl.operator.lowcode.common.utils import write_data, write_simple_json
-from ads.opctl.operator.lowcode.common.utils import default_signer
+from ads.opctl.operator.lowcode.common.utils import (
+    default_signer,
+    write_data,
+    write_simple_json,
+)
+
 from ..model.forecast_datasets import AdditionalData
 from ..operator_config import ForecastOperatorSpec
 
-from oci.data_science import DataScienceClient, DataScienceClientCompositeOperations
-
-from oci.data_science.models import ModelConfigurationDetails, InstanceConfiguration, \
-    FixedSizeScalingPolicy, CategoryLogDetails, LogDetails, \
-    SingleModelDeploymentConfigurationDetails, CreateModelDeploymentDetails
-from ads.common.object_storage_details import ObjectStorageDetails
-
 
 class ModelDeploymentManager:
-    def __init__(self, spec: ForecastOperatorSpec, additional_data: AdditionalData, previous_model_version=None):
+    def __init__(
+        self,
+        spec: ForecastOperatorSpec,
+        additional_data: AdditionalData,
+        previous_model_version=None,
+    ):
         self.spec = spec
         self.model_name = spec.model
         self.horizon = spec.horizon
         self.additional_data = additional_data.get_dict_by_series()
         self.model_obj = {}
         self.display_name = spec.what_if_analysis.model_display_name
-        self.project_id = spec.what_if_analysis.project_id if spec.what_if_analysis.project_id \
-            else os.environ.get('PROJECT_OCID')
-        self.compartment_id = spec.what_if_analysis.compartment_id if spec.what_if_analysis.compartment_id \
-            else os.environ.get('NB_SESSION_COMPARTMENT_OCID')
+        self.project_id = (
+            spec.what_if_analysis.project_id
+            if spec.what_if_analysis.project_id
+            else os.environ.get("PROJECT_OCID")
+        )
+        self.compartment_id = (
+            spec.what_if_analysis.compartment_id
+            if spec.what_if_analysis.compartment_id
+            else os.environ.get("NB_SESSION_COMPARTMENT_OCID")
+        )
         if self.project_id is None or self.compartment_id is None:
             raise ValueError("Either project_id or compartment_id cannot be None.")
         self.path_to_artifact = f"{self.spec.output_directory.url}/artifacts/"
@@ -58,17 +76,23 @@ class ModelDeploymentManager:
         try:
             sys.path.insert(0, f"{self.path_to_artifact}")
             from score import load_model, predict
+
             _ = load_model()
 
             # Write additional data to tmp file and perform sanity check
-            with tempfile.NamedTemporaryFile(suffix='.csv') as temp_file:
+            with tempfile.NamedTemporaryFile(suffix=".csv") as temp_file:
                 one_series = next(iter(self.additional_data))
-                sample_prediction_data = self.additional_data[one_series].tail(self.horizon)
-                sample_prediction_data[self.spec.target_category_columns[0]] = one_series
+                sample_prediction_data = self.additional_data[one_series].tail(
+                    self.horizon
+                )
+                sample_prediction_data[self.spec.target_category_columns[0]] = (
+                    one_series
+                )
                 date_col_name = self.spec.datetime_column.name
                 date_col_format = self.spec.datetime_column.format
-                sample_prediction_data[date_col_name] = sample_prediction_data[date_col_name].dt.strftime(
-                    date_col_format)
+                sample_prediction_data[date_col_name] = sample_prediction_data[
+                    date_col_name
+                ].dt.strftime(date_col_format)
                 sample_prediction_data.to_csv(temp_file.name, index=False)
                 input_data = {"additional_data": {"url": temp_file.name}}
                 prediction_test = predict(input_data, _)
@@ -86,16 +110,18 @@ class ModelDeploymentManager:
         try:
             current_dir = os.path.dirname(os.path.abspath(__file__))
             score_file = os.path.join(current_dir, "score.py")
-            destination_file = os.path.join(self.path_to_artifact, os.path.basename(score_file))
+            destination_file = os.path.join(
+                self.path_to_artifact, os.path.basename(score_file)
+            )
             shutil.copy2(score_file, destination_file)
             logger.info(f"score.py copied successfully to {self.path_to_artifact}")
         except Exception as e:
-            logger.warn(f"Error copying file: {e}")
+            logger.warning(f"Error copying file: {e}")
             raise e
 
     def save_to_catalog(self):
         """Save the model to a model catalog"""
-        with open(self.pickle_file_path, 'rb') as file:
+        with open(self.pickle_file_path, "rb") as file:
             self.model_obj = pickle.load(file)
 
         if not os.path.exists(self.path_to_artifact):
@@ -108,7 +134,8 @@ class ModelDeploymentManager:
             self.path_to_artifact,
             function_artifacts=False,
             force_overwrite=True,
-            data_science_env=True)
+            data_science_env=True,
+        )
 
         self._copy_score_file()
         self._sanity_test()
@@ -124,11 +151,14 @@ class ModelDeploymentManager:
                 display_name=self.display_name,
                 compartment_id=self.compartment_id,
                 project_id=self.project_id,
-                description=description)
+                description=description,
+            )
             self.catalog_id = catalog_entry.id
 
-        logger.info(f"Saved {self.model_name} version-v{self.model_version} to model catalog"
-                    f" with model ocid : {self.catalog_id}")
+        logger.info(
+            f"Saved {self.model_name} version-v{self.model_version} to model catalog"
+            f" with model ocid : {self.catalog_id}"
+        )
 
         self.deployment_info = {"model_ocid": self.catalog_id, "series": list(series)}
 
@@ -154,19 +184,25 @@ class ModelDeploymentManager:
                                 metric_type=auto_scaling_config.scaling_metric,
                                 scale_in_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
                                     scaling_configuration_type="THRESHOLD",
-                                    threshold=auto_scaling_config.scale_in_threshold
+                                    threshold=auto_scaling_config.scale_in_threshold,
                                 ),
                                 scale_out_configuration=oci.data_science.models.PredefinedExpressionThresholdScalingConfiguration(
                                     scaling_configuration_type="THRESHOLD",
-                                    threshold=auto_scaling_config.scale_out_threshold
-                                )
-                            )],
+                                    threshold=auto_scaling_config.scale_out_threshold,
+                                ),
+                            )
+                        ],
                         maximum_instance_count=auto_scaling_config.maximum_instance,
                         minimum_instance_count=auto_scaling_config.minimum_instance,
-                        initial_instance_count=auto_scaling_config.minimum_instance)],
+                        initial_instance_count=auto_scaling_config.minimum_instance,
+                    )
+                ],
                 cool_down_in_seconds=auto_scaling_config.cool_down_in_seconds,
-                is_enabled=True)
-            logger.info(f"Using autoscaling {auto_scaling_config.scaling_metric} for creating MD")
+                is_enabled=True,
+            )
+            logger.info(
+                f"Using autoscaling {auto_scaling_config.scaling_metric} for creating MD"
+            )
         else:
             scaling_policy = FixedSizeScalingPolicy(instance_count=1)
             logger.info("Using fixed size policy for creating MD")
@@ -174,13 +210,15 @@ class ModelDeploymentManager:
         model_configuration_details_object = ModelConfigurationDetails(
             model_id=self.catalog_id,
             instance_configuration=InstanceConfiguration(
-                instance_shape_name=initial_shape),
+                instance_shape_name=initial_shape
+            ),
             scaling_policy=scaling_policy,
-            bandwidth_mbps=20)
+            bandwidth_mbps=20,
+        )
 
         single_model_config = SingleModelDeploymentConfigurationDetails(
-            deployment_type='SINGLE_MODEL',
-            model_configuration_details=model_configuration_details_object
+            deployment_type="SINGLE_MODEL",
+            model_configuration_details=model_configuration_details_object,
         )
 
         log_group = self.spec.what_if_analysis.model_deployment.log_group
@@ -191,10 +229,9 @@ class ModelDeploymentManager:
             log_id = create_log_in_log_group(self.compartment_id, log_group, auth)
 
         logs_configuration_details_object = CategoryLogDetails(
-            access=LogDetails(log_group_id=log_group,
-                              log_id=log_id),
-            predict=LogDetails(log_group_id=log_group,
-                               log_id=log_id))
+            access=LogDetails(log_group_id=log_group, log_id=log_id),
+            predict=LogDetails(log_group_id=log_group, log_id=log_id),
+        )
 
         model_deploy_configuration = CreateModelDeploymentDetails(
             display_name=name,
@@ -202,24 +239,30 @@ class ModelDeploymentManager:
             project_id=self.project_id,
             compartment_id=self.compartment_id,
             model_deployment_configuration_details=single_model_config,
-            category_log_details=logs_configuration_details_object)
+            category_log_details=logs_configuration_details_object,
+        )
 
         if not self.test_mode:
             auth = oci.auth.signers.get_resource_principals_signer()
             data_science = DataScienceClient({}, signer=auth)
             data_science_composite = DataScienceClientCompositeOperations(data_science)
-            model_deployment = data_science_composite.create_model_deployment_and_wait_for_state(
-                model_deploy_configuration,
-                wait_for_states=[
-                    "SUCCEEDED", "FAILED"])
-            self.deployment_info['work_request'] = model_deployment.data.id
+            model_deployment = (
+                data_science_composite.create_model_deployment_and_wait_for_state(
+                    model_deploy_configuration, wait_for_states=["SUCCEEDED", "FAILED"]
+                )
+            )
+            self.deployment_info["work_request"] = model_deployment.data.id
             logger.info(f"deployment metadata :{model_deployment.data}")
-            md = data_science.get_model_deployment(model_deployment_id=model_deployment.data.resources[0].identifier)
-            self.deployment_info['model_deployment_ocid'] = md.data.id
-            self.deployment_info['status'] = md.data.lifecycle_state
+            md = data_science.get_model_deployment(
+                model_deployment_id=model_deployment.data.resources[0].identifier
+            )
+            self.deployment_info["model_deployment_ocid"] = md.data.id
+            self.deployment_info["status"] = md.data.lifecycle_state
             endpoint_url = md.data.model_deployment_url
-            self.deployment_info['model_deployment_endpoint'] = f"{endpoint_url}/predict"
-            self.deployment_info['log_id'] = log_id
+            self.deployment_info["model_deployment_endpoint"] = (
+                f"{endpoint_url}/predict"
+            )
+            self.deployment_info["log_id"] = log_id
 
     def save_deployment_info(self):
         output_dir = self.spec.output_directory.url
@@ -234,7 +277,9 @@ class ModelDeploymentManager:
             storage_options=storage_options,
             index=False,
             indent=4,
-            orient="records"
+            orient="records",
+        )
+        write_simple_json(
+            self.deployment_info, os.path.join(output_dir, "deployment_info.json")
         )
-        write_simple_json(self.deployment_info, os.path.join(output_dir, "deployment_info.json"))
         logger.info(f"Saved deployment info to {output_dir}")

{oracle_ads-2.13.2.dist-info → oracle_ads-2.13.2rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oracle_ads
-Version: 2.13.2
+Version: 2.13.2rc1
 Summary: Oracle Accelerated Data Science SDK
 Keywords: Oracle Cloud Infrastructure,OCI,Machine Learning,ML,Artificial Intelligence,AI,Data Science,Cloud,Oracle
 Author: Oracle Data Science