Resource Classes

class TrainingJob:
    """
    Training job resource.

    Class Methods:
        create(...) -> TrainingJob
            Create training job directly via API.
            
            Returns:
                TrainingJob: Created job
        
        get(training_job_name, sagemaker_session=None) -> TrainingJob
            Get existing training job.
            
            Parameters:
                training_job_name: str - Job name (required)
                sagemaker_session: Optional[Session] - Session
            
            Returns:
                TrainingJob: Job resource
            
            Raises:
                ClientError: If job not found

    Methods:
        refresh() -> TrainingJob
            Refresh job state from API.
            
            Returns:
                TrainingJob: Self with updated state
        
        wait(poll=5, timeout=None) -> None
            Wait for training completion.
            
            Parameters:
                poll: int - Polling interval in seconds (default: 5)
                timeout: Optional[int] - Timeout in seconds
            
            Raises:
                WaiterError: If job fails or timeout
        
        stop() -> None
            Stop the training job immediately.
            
            Raises:
                ClientError: If job already stopped or completed

    Attributes:
        training_job_name: str - Job name
        training_job_arn: str - Job ARN
        training_job_status: str - Status
            - "InProgress", "Completed", "Failed", "Stopping", "Stopped"
        model_artifacts: Dict - Model artifact S3 URI
        final_metric_data_list: List[Dict] - Final metrics
        creation_time: datetime - Creation timestamp
        training_start_time: datetime - Training start time
        training_end_time: datetime - Training end time
        failure_reason: Optional[str] - Failure reason if failed
        secondary_status: str - Detailed status
        billable_time_in_seconds: int - Billable time

    Notes:
        - Prefer ModelTrainer for standard training
        - Use for direct API access
        - All training job parameters available
    """

class ProcessingJob:
    """
    Processing job resource.

    Class Methods:
        create(...) -> ProcessingJob
        get(processing_job_name, sagemaker_session=None) -> ProcessingJob

    Methods:
        refresh() -> ProcessingJob
        wait(poll=5, timeout=None) -> None
        stop() -> None

    Attributes:
        processing_job_name: str - Job name
        processing_job_arn: str - Job ARN
        processing_job_status: str - Status
        processing_inputs: List[Dict] - Input configurations
        processing_outputs: List[Dict] - Output configurations
        failure_reason: Optional[str] - Failure reason

    Notes:
        - Prefer Processor for standard processing
        - Direct API access for advanced scenarios
    """

class TransformJob:
    """
    Batch transform job resource.

    Class Methods:
        create(...) -> TransformJob
        get(transform_job_name, sagemaker_session=None) -> TransformJob

    Methods:
        refresh() -> TransformJob
        wait(poll=5, timeout=None) -> None
        stop() -> None

    Attributes:
        transform_job_name: str - Job name
        transform_job_arn: str - Job ARN
        transform_job_status: str - Status
        model_name: str - Model used for transform
        transform_output: Dict - Output configuration

    Notes:
        - Prefer Transformer for standard batch inference
    """

class Model:
    """
    SageMaker Model resource.

    Class Methods:
        create(model_name, primary_container, execution_role_arn, vpc_config=None, 
               tags=None, sagemaker_session=None, ...) -> Model
            Create model resource.
            
            Parameters:
                model_name: str - Model name (required)
                primary_container: Dict - Container definition (required)
                execution_role_arn: str - Execution role (required)
                vpc_config: Optional[Dict] - VPC configuration
                tags: Optional[List[Tag]] - Tags
                sagemaker_session: Optional[Session] - Session
            
            Returns:
                Model: Created model
        
        get(model_name, sagemaker_session=None) -> Model
            Get existing model.
            
            Returns:
                Model: Model resource

    Methods:
        refresh() -> Model
            Refresh model state.
        
        delete() -> None
            Delete the model.
            
            Raises:
                ClientError: If model in use by endpoint

    Attributes:
        model_name: str - Model name
        model_arn: str - Model ARN
        primary_container: Dict - Primary container definition
        execution_role_arn: str - Execution role
        vpc_config: Optional[Dict] - VPC configuration
        creation_time: datetime - Creation timestamp

    Notes:
        - Prefer ModelBuilder for standard deployments
        - Use for multi-container models or advanced configs
    """

class Endpoint:
    """
    SageMaker Endpoint resource.

    Class Methods:
        create(endpoint_name, endpoint_config_name, tags=None, 
               sagemaker_session=None, ...) -> Endpoint
            Create endpoint.
            
            Returns:
                Endpoint: Created endpoint
        
        get(endpoint_name, sagemaker_session=None) -> Endpoint
            Get existing endpoint.
            
            Returns:
                Endpoint: Endpoint resource

    Methods:
        refresh() -> Endpoint
            Refresh endpoint state.
        
        delete() -> None
            Delete endpoint (model and config preserved).
        
        update(endpoint_config_name) -> None
            Update endpoint configuration.
            
            Parameters:
                endpoint_config_name: str - New config name (required)
        
        invoke(body, content_type=None, accept=None, custom_attributes=None, 
               target_model=None, target_variant=None, inference_id=None, 
               enable_explanations=None, inference_component_name=None) -> InvokeEndpointOutput
            Invoke endpoint for inference.
            
            Parameters:
                body: bytes - Request body (required)
                content_type: Optional[str] - Content type
                accept: Optional[str] - Accept type
                custom_attributes: Optional[str] - Custom attributes
                target_model: Optional[str] - Target model (multi-model)
                target_variant: Optional[str] - Target variant (A/B test)
                inference_id: Optional[str] - Inference ID for tracking
                enable_explanations: Optional[str] - Enable explainability
                inference_component_name: Optional[str] - Component name
            
            Returns:
                InvokeEndpointOutput: Response with Body, ContentType
            
            Raises:
                ClientError: Inference errors, throttling
        
        wait_for_in_service(poll=30, timeout=1800) -> None
            Wait until endpoint in service.
            
            Parameters:
                poll: int - Polling interval (default: 30 seconds)
                timeout: int - Timeout (default: 1800 seconds)
        
        wait_for_delete(poll=30, timeout=1800) -> None
            Wait for deletion to complete.

    Attributes:
        endpoint_name: str - Endpoint name
        endpoint_arn: str - Endpoint ARN
        endpoint_config_name: str - Config name
        endpoint_status: str - Status
            - "Creating", "InService", "Updating", "SystemUpdating", "RollingBack", "Failed", "Deleting"
        creation_time: datetime - Creation timestamp
        last_modified_time: datetime - Last modification time
        failure_reason: Optional[str] - Failure reason

    Notes:
        - Prefer ModelBuilder.deploy() for standard deployments
        - Direct invoke() for low-level control
        - Use for multi-variant endpoints, A/B testing
    """

from sagemaker.core.resources import Model, EndpointConfig, Endpoint

# Create model directly
model = Model.create(
    model_name="my-model",
    primary_container={
        "Image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/my-image:latest",
        "ModelDataUrl": "s3://my-bucket/model.tar.gz",
        "Environment": {
            "MODEL_NAME": "custom-model",
            "SAGEMAKER_PROGRAM": "inference.py"
        }
    },
    execution_role_arn="arn:aws:iam::123456789012:role/SageMakerRole"
)

# Create endpoint config
endpoint_config = EndpointConfig.create(
    endpoint_config_name="my-endpoint-config",
    production_variants=[{
        "VariantName": "variant-1",
        "ModelName": model.model_name,
        "InitialInstanceCount": 2,
        "InstanceType": "ml.m5.xlarge",
        "InitialVariantWeight": 1.0
    }]
)

# Create endpoint
endpoint = Endpoint.create(
    endpoint_name="my-endpoint",
    endpoint_config_name=endpoint_config.endpoint_config_name,
    tags=[{"Key": "Environment", "Value": "Production"}]
)

# Wait for endpoint to be ready
endpoint.wait_for_in_service()
print(f"Endpoint {endpoint.endpoint_name} is InService")

# Invoke endpoint
import json

request_body = json.dumps({"features": [1.0, 2.0, 3.0]}).encode('utf-8')

response = endpoint.invoke(
    body=request_body,
    content_type="application/json",
    accept="application/json"
)

result = json.loads(response['Body'].read())
print(f"Prediction: {result}")

# Clean up (delete in correct order)
endpoint.delete()
endpoint.wait_for_delete()
endpoint_config.delete()
model.delete()

class EndpointConfig:
    """
    Endpoint configuration resource.

    Class Methods:
        create(endpoint_config_name, production_variants, data_capture_config=None, 
               async_inference_config=None, explainer_config=None, tags=None, 
               kms_key_id=None, sagemaker_session=None, ...) -> EndpointConfig
            Create endpoint configuration.
            
            Returns:
                EndpointConfig: Created configuration
        
        get(endpoint_config_name, sagemaker_session=None) -> EndpointConfig
            Get existing configuration.

    Methods:
        refresh() -> EndpointConfig
        delete() -> None

    Attributes:
        endpoint_config_name: str - Config name
        endpoint_config_arn: str - Config ARN
        production_variants: List[Dict] - Variant configurations
        data_capture_config: Optional[Dict] - Data capture settings
        async_inference_config: Optional[Dict] - Async inference settings
        explainer_config: Optional[Dict] - Explainability settings
        creation_time: datetime - Creation timestamp

    Notes:
        - Separates configuration from endpoint lifecycle
        - Multiple endpoints can share same config
        - Update endpoint by creating new config
    """

class ModelPackage:
    """
    Model package resource for Model Registry.

    Class Methods:
        create(model_package_name=None, model_package_group_name=None, 
               inference_specification=None, validation_specification=None, 
               model_approval_status="PendingManualApproval", metadata_properties=None, 
               model_metrics=None, customer_metadata_properties=None, 
               drift_check_baselines=None, domain=None, task=None, 
               sample_payload_url=None, additional_inference_specifications=None, 
               tags=None, sagemaker_session=None, ...) -> ModelPackage
            Create model package.
            
            Returns:
                ModelPackage: Created package
        
        get(model_package_name, sagemaker_session=None) -> ModelPackage
            Get existing package.

    Methods:
        refresh() -> ModelPackage
        
        update(model_approval_status=None, approval_description=None, 
               customer_metadata_properties=None, inference_specification=None, 
               source_uri=None) -> None
            Update model package.
            
            Parameters:
                model_approval_status: Optional[str] - Approval status
                    - "Approved", "Rejected", "PendingManualApproval"
                approval_description: Optional[str] - Approval description
                customer_metadata_properties: Optional[Dict] - Metadata
                inference_specification: Optional[Dict] - Inference spec
                source_uri: Optional[str] - Source URI
        
        delete() -> None
            Delete model package.

    Attributes:
        model_package_name: str - Package name
        model_package_arn: str - Package ARN
        model_package_group_name: str - Package group
        model_package_version: int - Version number (auto-incremented)
        model_package_status: str - Status
        model_approval_status: str - Approval status
        inference_specification: Dict - Inference specification
        creation_time: datetime - Creation timestamp

    Notes:
        - Use for model versioning and governance
        - Approval workflow for production deployments
        - Versions automatically incremented in group
    """

class ModelPackageGroup:
    """
    Model package group resource.

    Class Methods:
        create(model_package_group_name, model_package_group_description=None, 
               tags=None, sagemaker_session=None, ...) -> ModelPackageGroup
        get(model_package_group_name, sagemaker_session=None) -> ModelPackageGroup

    Methods:
        refresh() -> ModelPackageGroup
        delete() -> None
            Delete group (all packages must be deleted first).

    Attributes:
        model_package_group_name: str - Group name
        model_package_group_arn: str - Group ARN
        model_package_group_description: str - Description
        creation_time: datetime - Creation timestamp

    Notes:
        - Groups organize related model versions
        - Cannot delete group with packages
        - Use for model lineage tracking
    """

from sagemaker.core.resources import ModelPackageGroup, ModelPackage

# Create model package group
group = ModelPackageGroup.create(
    model_package_group_name="customer-churn-models",
    model_package_group_description="Customer churn prediction models",
    tags=[{"Key": "Project", "Value": "ChurnPrediction"}]
)

# Register model to group (creates version 1)
model_package = ModelPackage.create(
    model_package_group_name=group.model_package_group_name,
    inference_specification={
        "Containers": [{
            "Image": "my-inference-image",
            "ModelDataUrl": "s3://bucket/model-v1.tar.gz"
        }],
        "SupportedContentTypes": ["application/json"],
        "SupportedResponseMIMETypes": ["application/json"],
        "SupportedRealtimeInferenceInstanceTypes": ["ml.m5.xlarge", "ml.m5.2xlarge"]
    },
    model_approval_status="PendingManualApproval",
    model_metrics={
        "ModelQuality": {
            "Statistics": {
                "ContentType": "application/json",
                "S3Uri": "s3://bucket/metrics/statistics.json"
            }
        }
    },
    customer_metadata_properties={
        "training_date": "2024-01-15",
        "accuracy": "0.94",
        "f1_score": "0.92"
    }
)

print(f"Model package version: {model_package.model_package_version}")

# Approve model
model_package.update(
    model_approval_status="Approved",
    approval_description="Model meets production criteria"
)

# Deploy approved model
model = Model.create(
    model_name="approved-churn-model",
    primary_container=model_package.inference_specification['Containers'][0],
    execution_role_arn=role_arn
)

class MonitoringSchedule:
    """
    Monitoring schedule resource.

    Class Methods:
        create(monitoring_schedule_name, monitoring_schedule_config, tags=None, 
               sagemaker_session=None, ...) -> MonitoringSchedule
        get(monitoring_schedule_name, sagemaker_session=None) -> MonitoringSchedule

    Methods:
        refresh() -> MonitoringSchedule
        update(monitoring_schedule_config) -> None
        delete() -> None
        start() -> None
            Start monitoring schedule.
        stop() -> None
            Stop monitoring schedule.

    Attributes:
        monitoring_schedule_name: str - Schedule name
        monitoring_schedule_arn: str - Schedule ARN
        monitoring_schedule_status: str - Status
            - "Pending", "Failed", "Scheduled", "Stopped"
        monitoring_schedule_config: Dict - Schedule configuration
        last_monitoring_execution_summary: Dict - Last execution summary
        creation_time: datetime - Creation timestamp

    Notes:
        - Prefer ModelMonitor classes for standard monitoring
        - Direct API access for custom monitoring
    """

class Experiment:
    """
    Experiment resource.

    Class Methods:
        create(experiment_name, description=None, display_name=None, tags=None, 
               sagemaker_session=None, ...) -> Experiment
        get(experiment_name, sagemaker_session=None) -> Experiment

    Methods:
        refresh() -> Experiment
        delete() -> None

    Attributes:
        experiment_name: str - Experiment name
        experiment_arn: str - Experiment ARN
        display_name: str - Display name
        description: str - Description
        creation_time: datetime - Creation timestamp

    Notes:
        - Prefer high-level Experiment class
        - Resource class for direct API access
    """

class Trial:
    """
    Trial resource.

    Class Methods:
        create(trial_name, experiment_name, display_name=None, tags=None, 
               sagemaker_session=None, ...) -> Trial
        get(trial_name, sagemaker_session=None) -> Trial

    Methods:
        refresh() -> Trial
        delete() -> None

    Attributes:
        trial_name: str - Trial name
        trial_arn: str - Trial ARN
        experiment_name: str - Parent experiment
        display_name: str - Display name
        creation_time: datetime - Creation timestamp

    Notes:
        - Prefer Run class for V3
        - Trial for V2 compatibility
    """

class Pipeline:
    """
    Pipeline resource.

    Class Methods:
        create(pipeline_name, pipeline_definition, pipeline_description=None, 
               role_arn, tags=None, parallelism_configuration=None, 
               sagemaker_session=None, ...) -> Pipeline
        get(pipeline_name, sagemaker_session=None) -> Pipeline

    Methods:
        refresh() -> Pipeline
        update(pipeline_definition=None, pipeline_description=None, role_arn=None, 
               parallelism_configuration=None) -> None
        delete() -> None
        start(pipeline_parameters=None, execution_display_name=None, 
              execution_description=None, parallelism_configuration=None, 
              selective_execution_config=None) -> PipelineExecution

    Attributes:
        pipeline_name: str - Pipeline name
        pipeline_arn: str - Pipeline ARN
        pipeline_display_name: str - Display name
        pipeline_description: str - Description
        role_arn: str - Execution role
        pipeline_definition: str - JSON definition
        creation_time: datetime - Creation timestamp

    Notes:
        - Prefer Pipeline from mlops.workflow
        - Resource for direct definition manipulation
    """

class PipelineExecution:
    """
    Pipeline execution resource.

    Class Methods:
        get(pipeline_execution_arn, sagemaker_session=None) -> PipelineExecution

    Methods:
        refresh() -> PipelineExecution
        stop() -> None
        wait(poll=30, timeout=None) -> None

    Attributes:
        pipeline_execution_arn: str - Execution ARN
        pipeline_execution_display_name: str - Display name
        pipeline_execution_status: str - Status
            - "Executing", "Stopping", "Stopped", "Failed", "Succeeded"
        pipeline_arn: str - Parent pipeline ARN
        pipeline_parameters: List[Dict] - Parameter values
        creation_time: datetime - Creation timestamp
        last_modified_time: datetime - Last modification time
        pipeline_execution_description: str - Description

    Notes:
        - Execution state management
        - Monitor execution progress
    """

class HyperParameterTuningJob:
    """
    Hyperparameter tuning job resource.

    Class Methods:
        create(...) -> HyperParameterTuningJob
        get(hyper_parameter_tuning_job_name, sagemaker_session=None) -> HyperParameterTuningJob

    Methods:
        refresh() -> HyperParameterTuningJob
        stop() -> None

    Attributes:
        hyper_parameter_tuning_job_name: str - Job name
        hyper_parameter_tuning_job_arn: str - Job ARN
        hyper_parameter_tuning_job_status: str - Status
        best_training_job: Dict - Best training job details
        training_job_status_counters: Dict - Job status counts
        objective_status_counters: Dict - Objective status counts

    Notes:
        - Prefer HyperparameterTuner
        - Resource for direct API access
    """

class FeatureGroup:
    """
    Feature store feature group resource.

    Class Methods:
        create(...) -> FeatureGroup
        get(feature_group_name, sagemaker_session=None) -> FeatureGroup

    Methods:
        refresh() -> FeatureGroup
        delete() -> None

    Attributes:
        feature_group_name: str - Feature group name
        feature_group_arn: str - Feature group ARN
        feature_group_status: str - Status
        record_identifier_feature_name: str - Record ID feature
        event_time_feature_name: str - Event time feature
        online_store_config: Optional[Dict] - Online store config
        offline_store_config: Optional[Dict] - Offline store config

    Notes:
        - Online store: low-latency retrieval
        - Offline store: S3-based historical features
    """

class NotebookInstance:
    """
    SageMaker notebook instance resource.

    Class Methods:
        create(...) -> NotebookInstance
        get(notebook_instance_name, sagemaker_session=None) -> NotebookInstance

    Methods:
        refresh() -> NotebookInstance
        start() -> None
        stop() -> None
        delete() -> None

    Attributes:
        notebook_instance_name: str - Instance name
        notebook_instance_arn: str - Instance ARN
        notebook_instance_status: str - Status
            - "Pending", "InService", "Stopping", "Stopped", "Failed", "Deleting", "Updating"
        instance_type: str - Instance type
        url: str - Notebook URL
        creation_time: datetime - Creation timestamp

    Notes:
        - Classic notebook instances (not Studio)
        - Manual lifecycle management
        - Billed when InService
    """

class Domain:
    """
    SageMaker Studio domain resource.

    Class Methods:
        create(...) -> Domain
        get(domain_id, sagemaker_session=None) -> Domain

    Methods:
        refresh() -> Domain
        delete() -> None

    Attributes:
        domain_id: str - Domain ID
        domain_arn: str - Domain ARN
        domain_name: str - Domain name
        status: str - Domain status
        home_efs_file_system_id: str - EFS file system ID
        auth_mode: str - Authentication mode

    Notes:
        - SageMaker Studio infrastructure
        - Contains user profiles and apps
    """

from sagemaker.core.resources import Model, EndpointConfig, Endpoint
import boto3

# Create model with multiple containers (pipeline)
model = Model.create(
    model_name="inference-pipeline",
    containers=[
        {
            "Image": "preprocessing-image",
            "ModelDataUrl": "s3://bucket/preprocessor.tar.gz",
            "Environment": {"STAGE": "preprocess"}
        },
        {
            "Image": "inference-image",
            "ModelDataUrl": "s3://bucket/model.tar.gz",
            "Environment": {"STAGE": "inference"}
        }
    ],
    execution_role_arn=role_arn
)

# Multi-variant endpoint config (A/B testing)
config = EndpointConfig.create(
    endpoint_config_name="ab-test-config",
    production_variants=[
        {
            "VariantName": "model-a",
            "ModelName": "model-a-name",
            "InitialInstanceCount": 1,
            "InstanceType": "ml.m5.xlarge",
            "InitialVariantWeight": 0.5  # 50% traffic
        },
        {
            "VariantName": "model-b",
            "ModelName": "model-b-name",
            "InitialInstanceCount": 1,
            "InstanceType": "ml.m5.xlarge",
            "InitialVariantWeight": 0.5  # 50% traffic
        }
    ]
)

# Create endpoint
endpoint = Endpoint.create(
    endpoint_name="ab-test-endpoint",
    endpoint_config_name=config.endpoint_config_name
)

endpoint.wait_for_in_service()

# Get resources
training_job = TrainingJob.get("my-training-job-2024-01-15")
model = Model.get("my-model")
endpoint = Endpoint.get("production-endpoint")

# Check status
endpoint.refresh()
print(f"Endpoint status: {endpoint.endpoint_status}")

if endpoint.endpoint_status == "InService":
    # Update endpoint with new config
    new_config = EndpointConfig.create(
        endpoint_config_name="new-config",
        production_variants=[...]
    )
    
    endpoint.update(endpoint_config_name=new_config.endpoint_config_name)
    endpoint.wait_for_in_service()
    
    print("Endpoint updated successfully")

# Delete resources in correct order
# 1. Delete endpoint (releases instances)
try:
    endpoint.delete()
    endpoint.wait_for_delete()
    print("Endpoint deleted")
except ClientError as e:
    print(f"Endpoint deletion error: {e}")

# 2. Delete endpoint config
try:
    endpoint_config.delete()
    print("Endpoint config deleted")
except ClientError as e:
    print(f"Config deletion error: {e}")

# 3. Delete model
try:
    model.delete()
    print("Model deleted")
except ClientError as e:
    if e.response['Error']['Code'] == 'ResourceInUse':
        print("Model still in use by another endpoint")
    else:
        raise

from sagemaker.core.resources import Endpoint, Model

# List all endpoints
import boto3
sagemaker = boto3.client('sagemaker')

response = sagemaker.list_endpoints(MaxResults=100)

# Check status of all endpoints
for ep_summary in response['Endpoints']:
    endpoint = Endpoint.get(ep_summary['EndpointName'])
    
    print(f"{endpoint.endpoint_name}:")
    print(f"  Status: {endpoint.endpoint_status}")
    print(f"  Created: {endpoint.creation_time}")
    print(f"  Config: {endpoint.endpoint_config_name}")
    
    # Take action based on status
    if endpoint.endpoint_status == "Failed":
        print(f"  Failure reason: {endpoint.failure_reason}")
        # Optionally delete failed endpoints
        # endpoint.delete()