workbench 0.8.161__py3-none-any.whl → 0.8.192__py3-none-any.whl

workbench/core/artifacts/model_core.py

@@ -21,6 +21,7 @@ from workbench.utils.aws_utils import newest_path, pull_s3_data
 from workbench.utils.s3_utils import compute_s3_object_hash
 from workbench.utils.shap_utils import shap_values_data, shap_feature_importance
 from workbench.utils.deprecated_utils import deprecated
+from workbench.utils.model_utils import proximity_model
 
 
 class ModelType(Enum):
@@ -42,11 +43,11 @@ class ModelImages:
 
     image_uris = {
         # US East 1 images
-        ("us-east-1", "xgb_training", "0.1", "x86_64"): (
-            "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-sklearn-xgb-training:0.1"
+        ("us-east-1", "training", "0.1", "x86_64"): (
+            "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-general-ml-training:0.1"
         ),
-        ("us-east-1", "xgb_inference", "0.1", "x86_64"): (
-            "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-sklearn-xgb-inference:0.1"
+        ("us-east-1", "inference", "0.1", "x86_64"): (
+            "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-general-ml-inference:0.1"
         ),
         ("us-east-1", "pytorch_training", "0.1", "x86_64"): (
             "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-pytorch-training:0.1"
@@ -55,11 +56,11 @@ class ModelImages:
             "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-pytorch-inference:0.1"
         ),
         # US West 2 images
-        ("us-west-2", "xgb_training", "0.1", "x86_64"): (
-            "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-sklearn-xgb-training:0.1"
+        ("us-west-2", "training", "0.1", "x86_64"): (
+            "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-general-ml-training:0.1"
         ),
-        ("us-west-2", "xgb_inference", "0.1", "x86_64"): (
-            "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-sklearn-xgb-inference:0.1"
+        ("us-west-2", "inference", "0.1", "x86_64"): (
+            "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-general-ml-inference:0.1"
         ),
         ("us-west-2", "pytorch_training", "0.1", "x86_64"): (
             "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-pytorch-training:0.1"
@@ -68,12 +69,6 @@ class ModelImages:
             "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-pytorch-inference:0.1"
         ),
         # ARM64 images
-        ("us-east-1", "xgb_inference", "0.1", "arm64"): (
-            "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-sklearn-xgb-inference:0.1-arm64"
-        ),
-        ("us-west-2", "xgb_inference", "0.1", "arm64"): (
-            "507740646243.dkr.ecr.us-west-2.amazonaws.com/aws-ml-images/py312-sklearn-xgb-inference:0.1-arm64"
-        ),
         # Meta Endpoint inference images
         ("us-east-1", "meta-endpoint", "0.1", "x86_64"): (
             "507740646243.dkr.ecr.us-east-1.amazonaws.com/aws-ml-images/py312-meta-endpoint:0.1"
@@ -597,6 +592,24 @@ class ModelCore(Artifact):
         # Return the details
         return details
 
+    # Training View for this model
+    def training_view(self):
+        """Get the training view for this model"""
+        from workbench.core.artifacts.feature_set_core import FeatureSetCore
+        from workbench.core.views import View
+
+        # Grab our FeatureSet
+        fs = FeatureSetCore(self.get_input())
+
+        # See if we have a training view for this model
+        my_model_training_view = f"{self.name.replace('-', '_')}_training"
+        view = View(fs, my_model_training_view, auto_create_view=False)
+        if view.exists():
+            return view
+        else:
+            self.log.important(f"No specific training view {my_model_training_view}, returning default training view")
+            return fs.view("training")
+
     # Pipeline for this model
     def get_pipeline(self) -> str:
         """Get the pipeline for this model"""
@@ -867,6 +880,14 @@ class ModelCore(Artifact):
                 shap_data[key] = self.df_store.get(df_location)
             return shap_data or None
 
+    def cross_folds(self) -> dict:
+        """Retrieve the cross-fold inference results(only works for XGBoost models)
+
+        Returns:
+            dict: Dictionary with the cross-fold inference results
+        """
+        return self.param_store.get(f"/workbench/models/{self.name}/inference/cross_fold")
+
     def supported_inference_instances(self) -> Optional[list]:
         """Retrieve the supported endpoint inference instance types
 
@@ -879,10 +900,24 @@ class ModelCore(Artifact):
         except (KeyError, IndexError, TypeError):
             return None
 
+    def publish_prox_model(self, prox_model_name: str = None, track_columns: list = None):
+        """Create and publish a Proximity Model for this Model
+
+        Args:
+            prox_model_name (str, optional): Name of the Proximity Model (if not specified, a name will be generated)
+            track_columns (list, optional): List of columns to track in the Proximity Model.
+
+        Returns:
+            Model: The published Proximity Model
+        """
+        if prox_model_name is None:
+            prox_model_name = self.model_name + "-prox"
+        return proximity_model(self, prox_model_name, track_columns=track_columns)
+
     def delete(self):
         """Delete the Model Packages and the Model Group"""
         if not self.exists():
-            self.log.warning(f"Trying to delete an Model that doesn't exist: {self.name}")
+            self.log.warning(f"Trying to delete a Model that doesn't exist: {self.name}")
 
         # Call the Class Method to delete the Model Group
         ModelCore.managed_delete(model_group_name=self.name)

workbench/core/artifacts/monitor_core.py

@@ -2,12 +2,10 @@
 
 import logging
 import json
-from typing import Union, Tuple
+from typing import Union
 import pandas as pd
-from sagemaker import Predictor
 from sagemaker.model_monitor import (
     CronExpressionGenerator,
-    DataCaptureConfig,
     DefaultModelMonitor,
     DatasetFormat,
 )
@@ -15,29 +13,32 @@ import awswrangler as wr
 
 # Workbench Imports
 from workbench.core.artifacts.endpoint_core import EndpointCore
+from workbench.core.artifacts.data_capture_core import DataCaptureCore
 from workbench.api import Model, FeatureSet
 from workbench.core.cloud_platform.aws.aws_account_clamp import AWSAccountClamp
 from workbench.utils.s3_utils import read_content_from_s3, upload_content_to_s3
 from workbench.utils.datetime_utils import datetime_string
 from workbench.utils.monitor_utils import (
-    process_data_capture,
     get_monitor_json_data,
     parse_monitoring_results,
     preprocessing_script,
 )
 
-# Note: This resource might come in handy when doing code refactoring
+# Note: These resources might come in handy when doing code refactoring
 # https://github.com/aws-samples/amazon-sagemaker-from-idea-to-production/blob/master/06-monitoring.ipynb
 # https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-pre-and-post-processing.html
 # https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/introduction/SageMaker-ModelMonitoring.ipynb
 
 
 class MonitorCore:
+    """Manages monitoring, baselines, and monitoring schedules for SageMaker endpoints"""
+
     def __init__(self, endpoint_name, instance_type="ml.m5.large"):
         """MonitorCore Class
+
         Args:
             endpoint_name (str): Name of the endpoint to set up monitoring for
-            instance_type (str): Instance type to use for monitoring. Defaults to "ml.t3.medium".
+            instance_type (str): Instance type to use for monitoring. Defaults to "ml.m5.large".
         """
         self.log = logging.getLogger("workbench")
         self.endpoint_name = endpoint_name
@@ -46,7 +47,6 @@ class MonitorCore:
         # Initialize Class Attributes
         self.sagemaker_session = self.endpoint.sm_session
         self.sagemaker_client = self.endpoint.sm_client
-        self.data_capture_path = self.endpoint.endpoint_data_capture_path
         self.monitoring_path = self.endpoint.endpoint_monitoring_path
         self.monitoring_schedule_name = f"{self.endpoint_name}-monitoring-schedule"
         self.baseline_dir = f"{self.monitoring_path}/baseline"
@@ -57,6 +57,10 @@ class MonitorCore:
         self.workbench_role_arn = AWSAccountClamp().aws_session.get_workbench_execution_role_arn()
         self.instance_type = instance_type
 
+        # Create DataCaptureCore instance for composition
+        self.data_capture = DataCaptureCore(endpoint_name)
+        self.data_capture_path = self.data_capture.data_capture_path
+
         # Check if a monitoring schedule already exists for this endpoint
         existing_schedule = self.monitoring_schedule_exists()
 
@@ -74,23 +78,20 @@ class MonitorCore:
             self.log.info(f"Initialized new model monitor for {self.endpoint_name}")
 
     def summary(self) -> dict:
-        """Return the summary of information about the endpoint monitor
+        """Return the summary of monitoring configuration
 
         Returns:
-            dict: Summary of information about the endpoint monitor
+            dict: Summary of monitoring status
         """
         if self.endpoint.is_serverless():
             return {
                 "endpoint_type": "serverless",
-                "data_capture": "not supported",
                 "baseline": "not supported",
                 "monitoring_schedule": "not supported",
             }
         else:
             summary = {
                 "endpoint_type": "realtime",
-                "data_capture": self.data_capture_enabled(),
-                "capture_percent": self.data_capture_percent(),
                 "baseline": self.baseline_exists(),
                 "monitoring_schedule": self.monitoring_schedule_exists(),
                 "preprocessing": self.preprocessing_exists(),
@@ -103,22 +104,15 @@ class MonitorCore:
         Returns:
             dict: The monitoring details for the endpoint
         """
-        # Get the actual data capture path
-        actual_capture_path = self.data_capture_config()["DestinationS3Uri"]
-        if actual_capture_path != self.data_capture_path:
-            self.log.warning(
-                f"Data capture path mismatch: Expected {self.data_capture_path}, "
-                f"but found {actual_capture_path}. Using the actual path."
-            )
-            self.data_capture_path = actual_capture_path
         result = self.summary()
         info = {
-            "data_capture_path": self.data_capture_path if self.data_capture_enabled() else None,
-            "preprocessing_script_file": self.preprocessing_script_file if self.preprocessing_exists() else None,
             "monitoring_schedule_status": "Not Scheduled",
         }
         result.update(info)
 
+        if self.preprocessing_exists():
+            result["preprocessing_script_file"] = self.preprocessing_script_file
+
         if self.baseline_exists():
             result.update(
                 {
@@ -144,7 +138,6 @@ class MonitorCore:
 
             last_run = schedule_details.get("LastMonitoringExecutionSummary", {})
             if last_run:
-
                 # If no inference was run since the last monitoring schedule, the
                 # status will be "Failed" with reason "Job inputs had no data",
                 # so we check for that and set the status to "No New Data"
@@ -162,187 +155,22 @@ class MonitorCore:
 
         return result
 
-    def enable_data_capture(self, capture_percentage=100, force=False):
-        """
-        Enable data capture for the SageMaker endpoint.
+    def enable_data_capture(self, capture_percentage=100):
+        """Enable data capture for the endpoint
 
         Args:
-            capture_percentage (int): Percentage of data to capture. Defaults to 100.
-            force (bool): If True, force reconfiguration even if data capture is already enabled.
+            capture_percentage (int): Percentage of requests to capture (0-100, default 100)
         """
-        # Early returns for cases where we can't/don't need to add data capture
         if self.endpoint.is_serverless():
             self.log.warning("Data capture is not supported for serverless endpoints.")
             return
 
-        if self.data_capture_enabled() and not force:
-            self.log.important(f"Data capture already configured for {self.endpoint_name}.")
-            return
-
-        # Get the current endpoint configuration name for later deletion
-        current_endpoint_config_name = self.endpoint.endpoint_config_name()
-
-        # Log the data capture operation
-        self.log.important(f"Enabling Data Capture for {self.endpoint_name} --> {self.data_capture_path}")
-        self.log.important("This normally redeploys the endpoint...")
-
-        # Create and apply the data capture configuration
-        data_capture_config = DataCaptureConfig(
-            enable_capture=True,  # Required parameter
-            sampling_percentage=capture_percentage,
-            destination_s3_uri=self.data_capture_path,
-        )
-
-        # Update endpoint with the new capture configuration
-        Predictor(self.endpoint_name, sagemaker_session=self.sagemaker_session).update_data_capture_config(
-            data_capture_config=data_capture_config
-        )
-
-        # Clean up old endpoint configuration
-        self.sagemaker_client.delete_endpoint_config(EndpointConfigName=current_endpoint_config_name)
-
-    def data_capture_config(self):
-        """
-        Returns the complete data capture configuration from the endpoint config.
-        Returns:
-            dict: Complete DataCaptureConfig from AWS, or None if not configured
-        """
-        config_name = self.endpoint.endpoint_config_name()
-        response = self.sagemaker_client.describe_endpoint_config(EndpointConfigName=config_name)
-        data_capture_config = response.get("DataCaptureConfig")
-        if not data_capture_config:
-            self.log.error(f"No data capture configuration found for endpoint config {config_name}")
-            return None
-        return data_capture_config
-
-    def disable_data_capture(self):
-        """
-        Disable data capture for the SageMaker endpoint.
-        """
-        # Early return if data capture isn't configured
-        if not self.data_capture_enabled():
-            self.log.important(f"Data capture is not currently enabled for {self.endpoint_name}.")
+        if self.data_capture.is_enabled():
+            self.log.info(f"Data capture is already enabled for {self.endpoint_name}.")
             return
 
-        # Get the current endpoint configuration name for later deletion
-        current_endpoint_config_name = self.endpoint.endpoint_config_name()
-
-        # Log the operation
-        self.log.important(f"Disabling Data Capture for {self.endpoint_name}")
-        self.log.important("This normally redeploys the endpoint...")
-
-        # Create a configuration with capture disabled
-        data_capture_config = DataCaptureConfig(enable_capture=False, destination_s3_uri=self.data_capture_path)
-
-        # Update endpoint with the new configuration
-        Predictor(self.endpoint_name, sagemaker_session=self.sagemaker_session).update_data_capture_config(
-            data_capture_config=data_capture_config
-        )
-
-        # Clean up old endpoint configuration
-        self.sagemaker_client.delete_endpoint_config(EndpointConfigName=current_endpoint_config_name)
-
-    def data_capture_enabled(self):
-        """
-        Check if data capture is already configured on the endpoint.
-        Args:
-            capture_percentage (int): Expected data capture percentage.
-        Returns:
-            bool: True if data capture is already configured, False otherwise.
-        """
-        try:
-            endpoint_config_name = self.endpoint.endpoint_config_name()
-            endpoint_config = self.sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_config_name)
-            data_capture_config = endpoint_config.get("DataCaptureConfig", {})
-
-            # Check if data capture is enabled and the percentage matches
-            is_enabled = data_capture_config.get("EnableCapture", False)
-            return is_enabled
-        except Exception as e:
-            self.log.error(f"Error checking data capture configuration: {e}")
-            return False
-
-    def data_capture_percent(self):
-        """
-        Get the data capture percentage from the endpoint configuration.
-
-        Returns:
-            int: Data capture percentage if enabled, None otherwise.
-        """
-        try:
-            endpoint_config_name = self.endpoint.endpoint_config_name()
-            endpoint_config = self.sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_config_name)
-            data_capture_config = endpoint_config.get("DataCaptureConfig", {})
-
-            # Check if data capture is enabled and return the percentage
-            if data_capture_config.get("EnableCapture", False):
-                return data_capture_config.get("InitialSamplingPercentage", 0)
-            else:
-                return None
-        except Exception as e:
-            self.log.error(f"Error checking data capture percentage: {e}")
-            return None
-
-    def get_captured_data(self, max_files=None, add_timestamp=True) -> Tuple[pd.DataFrame, pd.DataFrame]:
-        """
-        Read and process captured data from S3.
-
-        Args:
-            max_files (int, optional): Maximum number of files to process.
-                                       Defaults to None to process all files.
-            add_timestamp (bool, optional): Whether to add a timestamp column to the DataFrame.
-
-        Returns:
-            Tuple[pd.DataFrame, pd.DataFrame]: Processed input and output DataFrames.
-        """
-        # List files in the specified S3 path
-        files = wr.s3.list_objects(self.data_capture_path)
-        if not files:
-            self.log.warning(f"No data capture files found in {self.data_capture_path}.")
-            return pd.DataFrame(), pd.DataFrame()
-
-        self.log.info(f"Found {len(files)} files in {self.data_capture_path}.")
-
-        # Sort files by timestamp (assuming the naming convention includes timestamp)
-        files.sort()
-
-        # Select files to process
-        if max_files is None:
-            files_to_process = files
-            self.log.info(f"Processing all {len(files)} files.")
-        else:
-            files_to_process = files[-max_files:] if files else []
-            self.log.info(f"Processing the {len(files_to_process)} most recent file(s).")
-
-        # Process each file
-        all_input_dfs = []
-        all_output_dfs = []
-        for file_path in files_to_process:
-            self.log.info(f"Processing {file_path}...")
-            try:
-                # Read the JSON lines file
-                df = wr.s3.read_json(path=file_path, lines=True)
-                if not df.empty:
-                    input_df, output_df = process_data_capture(df)
-                    # Generate a timestamp column if requested
-                    if add_timestamp:
-                        # Get file metadata to extract last modified time
-                        file_metadata = wr.s3.describe_objects(path=file_path)
-                        timestamp = file_metadata[file_path]["LastModified"]
-                        output_df["timestamp"] = timestamp
-
-                    # Append the processed DataFrames to the lists
-                    all_input_dfs.append(input_df)
-                    all_output_dfs.append(output_df)
-            except Exception as e:
-                self.log.warning(f"Error processing file {file_path}: {e}")
-
-        # Combine all DataFrames
-        if not all_input_dfs or not all_output_dfs:
-            self.log.warning("No valid data was processed from the captured files.")
-            return pd.DataFrame(), pd.DataFrame()
-
-        return pd.concat(all_input_dfs, ignore_index=True), pd.concat(all_output_dfs, ignore_index=True)
+        self.data_capture.enable(capture_percentage=capture_percentage)
+        self.log.important(f"Enabled data capture for {self.endpoint_name} at {self.data_capture_path}")
 
     def baseline_exists(self) -> bool:
         """
@@ -533,6 +361,11 @@ class MonitorCore:
             self.log.warning("If you want to create another one, delete existing schedule first.")
             return
 
+        # Check if data capture is enabled, if not enable it
+        if not self.data_capture.is_enabled():
+            self.log.warning("Data capture is not enabled for this endpoint. Enabling it now...")
+            self.enable_data_capture(capture_percentage=100)
+
         # Set up a NEW monitoring schedule
         schedule_args = {
             "monitor_schedule_name": self.monitoring_schedule_name,
@@ -577,33 +410,6 @@ class MonitorCore:
         self.model_monitor.delete_monitoring_schedule()
         self.log.important(f"Deleted monitoring schedule for {self.endpoint_name}.")
 
-    # Put this functionality into this class
-    """
-    executions = my_monitor.list_executions()
-    latest_execution = executions[-1]
-
-    latest_execution.describe()['ProcessingJobStatus']
-    latest_execution.describe()['ExitMessage']
-    Here are the possible terminal states and what each of them means:
-
-    - Completed - This means the monitoring execution completed and no issues were found in the violations report.
-    - CompletedWithViolations - This means the execution completed, but constraint violations were detected.
-    - Failed - The monitoring execution failed, maybe due to client error
-                (perhaps incorrect role premissions) or infrastructure issues. Further
-                examination of the FailureReason and ExitMessage is necessary to identify what exactly happened.
-    - Stopped - job exceeded the max runtime or was manually stopped.
-    You can also get the S3 URI for the output with latest_execution.output.destination and analyze the results.
-
-    Visualize results
-    You can use the monitor object to gather reports for visualization:
-
-    suggested_constraints = my_monitor.suggested_constraints()
-    baseline_statistics = my_monitor.baseline_statistics()
-
-    latest_monitoring_violations = my_monitor.latest_monitoring_constraint_violations()
-    latest_monitoring_statistics = my_monitor.latest_monitoring_statistics()
-    """
-
     def get_monitoring_results(self, max_results=10) -> pd.DataFrame:
         """Get the results of monitoring executions
 
@@ -758,7 +564,7 @@ class MonitorCore:
         Returns:
             str: String representation of this MonitorCore object
         """
-        summary_dict = {}  # Disabling for now self.summary()
+        summary_dict = self.summary()
         summary_items = [f"  {repr(key)}: {repr(value)}" for key, value in summary_dict.items()]
         summary_str = f"{self.__class__.__name__}: {self.endpoint_name}\n" + ",\n".join(summary_items)
         return summary_str
@@ -775,7 +581,6 @@ if __name__ == "__main__":
 
     # Create the Class and test it out
     endpoint_name = "abalone-regression-rt"
-    endpoint_name = "logd-dev-reg-rt"
     my_endpoint = EndpointCore(endpoint_name)
     if not my_endpoint.exists():
         print(f"Endpoint {endpoint_name} does not exist.")
@@ -788,11 +593,10 @@ if __name__ == "__main__":
     # Check the details of the monitoring class
     pprint(mm.details())
 
-    # Enable data capture on the endpoint
-    mm.enable_data_capture()
+    # Enable data capture (if not already enabled)
+    mm.enable_data_capture(capture_percentage=100)
 
     # Create a baseline for monitoring
-    # mm.create_baseline(recreate=True)
     mm.create_baseline()
 
     # Check the monitoring outputs
@@ -804,30 +608,11 @@ if __name__ == "__main__":
     pprint(mm.get_constraints())
 
     print("\nStatistics...")
-    print(mm.get_statistics())
+    print(str(mm.get_statistics())[:1000])  # Print only first 1000 characters
 
     # Set up the monitoring schedule (if it doesn't already exist)
     mm.create_monitoring_schedule()
 
-    #
-    # Test the data capture by running some predictions
-    #
-
-    # Make predictions on the Endpoint using the FeatureSet evaluation data
-    # pred_df = my_endpoint.auto_inference()
-    # print(pred_df.head())
-
-    # Check that data capture is working
-    input_df, output_df = mm.get_captured_data()
-    if input_df.empty or output_df.empty:
-        print("No data capture files found, for a new endpoint it may take a few minutes to start capturing data")
-    else:
-        print("Found data capture files")
-        print("Input")
-        print(input_df.head())
-        print("Output")
-        print(output_df.head())
-
     # Test update_constraints (commented out for now)
     # print("\nTesting constraint updates...")
     # custom_constraints = {"sex": {"allowed_values": ["M", "F", "I"]}, "length": {"min": 0.0, "max": 1.0}}
@@ -846,7 +631,7 @@ if __name__ == "__main__":
     print("\nTesting execution details retrieval...")
     if not results_df.empty:
         latest_execution_arn = results_df.iloc[0]["processing_job_arn"]
-        execution_details = mm.get_execution_details(latest_execution_arn)
+        execution_details = mm.get_execution_details(latest_execution_arn) if latest_execution_arn else None
         if execution_details:
             print(f"Execution details for {latest_execution_arn}:")
             pprint(execution_details)

workbench/core/cloud_platform/aws/aws_account_clamp.py

@@ -54,7 +54,11 @@ class AWSAccountClamp:
 
         # Check our Assume Role
         self.log.info("Checking Workbench Assumed Role...")
-        self.aws_session.assumed_role_info()
+        role_info = self.aws_session.assumed_role_info()
+        self.log.info(f"Assumed Role: {role_info}")
+
+        # Check if we have tag write permissions (if we don't, we are read-only)
+        self.read_only = not self.check_tag_permissions()
 
         # Check our Workbench API Key and Load the License
         self.log.info("Checking Workbench API License...")
@@ -138,6 +142,45 @@ class AWSAccountClamp:
         """
         return self.boto3_session.client("sagemaker")
 
+    def check_tag_permissions(self):
+        """Check if current role has permission to add tags to SageMaker endpoints.
+
+        Returns:
+            bool: True if AddTags is allowed, False otherwise
+        """
+        try:
+            sagemaker = self.boto3_session.client("sagemaker")
+
+            # Use a non-existent endpoint name
+            fake_endpoint = "workbench-permission-check-dummy-endpoint"
+
+            # Try to add tags to the non-existent endpoint
+            sagemaker.add_tags(
+                ResourceArn=f"arn:aws:sagemaker:{self.region}:{self.account_id}:endpoint/{fake_endpoint}",
+                Tags=[{"Key": "PermissionCheck", "Value": "Test"}],
+            )
+
+            # If we get here, we have permission (but endpoint doesn't exist)
+            return True
+
+        except ClientError as e:
+            error_code = e.response["Error"]["Code"]
+
+            # AccessDeniedException = no permission
+            if error_code == "AccessDeniedException":
+                self.log.debug("No AddTags permission (AccessDeniedException)")
+                return False
+
+            # ResourceNotFound = we have permission, but endpoint doesn't exist
+            elif error_code in ["ResourceNotFound", "ValidationException"]:
+                self.log.debug("AddTags permission verified (resource not found)")
+                return True
+
+            # Unexpected error, assume no permission for safety
+            else:
+                self.log.debug(f"Unexpected error checking permissions: {error_code}")
+                return False
+
 
 if __name__ == "__main__":
     """Exercise the AWS Account Clamp Class"""
@@ -162,3 +205,9 @@ if __name__ == "__main__":
     print("\n\n*** AWS Sagemaker Session/Client Check ***")
     sm_client = aws_account_clamp.sagemaker_client()
     print(sm_client.list_feature_groups()["FeatureGroupSummaries"])
+
+    print("\n\n*** AWS Tag Permission Check ***")
+    if aws_account_clamp.check_tag_permissions():
+        print("Tag Permission Check Success...")
+    else:
+        print("Tag Permission Check Failed...")

workbench/core/cloud_platform/aws/aws_meta.py

@@ -196,7 +196,9 @@ class AWSMeta:
 
         # Return the summary as a DataFrame
         df = pd.DataFrame(data_summary).convert_dtypes()
-        return df.sort_values(by="Created", ascending=False)
+        if not df.empty:
+            df.sort_values(by="Created", ascending=False, inplace=True)
+        return df
 
     def models(self, details: bool = False) -> pd.DataFrame:
         """Get a summary of the Models in AWS.
@@ -256,7 +258,9 @@ class AWSMeta:
 
         # Return the summary as a DataFrame
         df = pd.DataFrame(model_summary).convert_dtypes()
-        return df.sort_values(by="Created", ascending=False)
+        if not df.empty:
+            df.sort_values(by="Created", ascending=False, inplace=True)
+        return df
 
     def endpoints(self, details: bool = False) -> pd.DataFrame:
         """Get a summary of the Endpoints in AWS.
@@ -308,7 +312,7 @@ class AWSMeta:
                     "Status": endpoint_details.get("EndpointStatus", "-"),
                     "Config": endpoint_details.get("EndpointConfigName", "-"),
                     "Variant": endpoint_details["config"]["variant"],
-                    "Capture": str(endpoint_details.get("DataCaptureConfig", {}).get("EnableCapture", "False")),
+                    "Capture": str(endpoint_details.get("DataCaptureConfig", {}).get("EnableCapture", "-")),
                     "Samp(%)": str(endpoint_details.get("DataCaptureConfig", {}).get("CurrentSamplingPercentage", "-")),
                     "Tags": aws_tags.get("workbench_tags", "-"),
                     "Monitored": endpoint_details["monitored"],
@@ -317,7 +321,9 @@ class AWSMeta:
 
         # Return the summary as a DataFrame
         df = pd.DataFrame(data_summary).convert_dtypes()
-        return df.sort_values(by="Created", ascending=False)
+        if not df.empty:
+            df.sort_values(by="Created", ascending=False, inplace=True)
+        return df
 
     def _endpoint_config_info(self, endpoint_config_name: str) -> dict:
         """Internal: Get the Endpoint Configuration information for the given endpoint config name.
@@ -657,7 +663,8 @@ class AWSMeta:
         df = pd.DataFrame(data_summary).convert_dtypes()
 
         # Sort by the Modified column
-        df = df.sort_values(by="Modified", ascending=False)
+        if not df.empty:
+            df = df.sort_values(by="Modified", ascending=False)
         return df
 
     def _aws_pipelines(self) -> pd.DataFrame: