workbench 0.8.166__tar.gz → 0.8.168__tar.gz

{workbench-0.8.166 → workbench-0.8.168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.166
+Version: 0.8.168
 Summary: Workbench: A Dashboard and Python API for creating and deploying AWS SageMaker Model Pipelines
 Author-email: SuperCowPowers LLC <support@supercowpowers.com>
 License-Expression: MIT

workbench-0.8.168/aws_setup/workbench_core/app.py

@@ -0,0 +1,70 @@
+import os
+import boto3
+import logging
+import aws_cdk as cdk
+from workbench_core.workbench_core_stack import WorkbenchCoreStack, WorkbenchCoreStackProps
+
+# Initialize ConfigManager with error handling
+try:
+    # Temporarily disable logging
+    # logging.disable(logging.CRITICAL)
+    from workbench.utils.config_manager import ConfigManager
+
+    cm = ConfigManager()
+except Exception as e:
+    print(f"Workbench ConfigManager initialization failed: {e}")
+    print("Falling back to environment variables only")
+    cm = None
+finally:
+    # Re-enable logging
+    logging.disable(logging.NOTSET)
+
+# Grab the account and region using boto3
+session = boto3.session.Session()
+aws_account = session.client("sts").get_caller_identity().get("Account")
+aws_region = session.region_name
+print(f"Account: {aws_account}")
+print(f"Region: {aws_region}")
+
+# Get configurations for Workbench Bucket, SSO Group, and Additional Buckets
+workbench_bucket = (cm and cm.get_config("WORKBENCH_BUCKET")) or os.getenv("WORKBENCH_BUCKET")
+if not workbench_bucket:
+    print("Error: WORKBENCH_BUCKET is required but not found in config or environment variables.")
+    exit(1)
+sso_group = (cm and cm.get_config("WORKBENCH_SSO_GROUP")) or os.getenv("WORKBENCH_SSO_GROUP")
+additional_buckets_str = (cm and cm.get_config("WORKBENCH_ADDITIONAL_BUCKETS")) or os.getenv(
+    "WORKBENCH_ADDITIONAL_BUCKETS", ""
+)
+additional_buckets = (
+    [bucket.strip() for bucket in additional_buckets_str.split(",") if bucket.strip()] if additional_buckets_str else []
+)
+existing_vpc_id = (cm and cm.get_config("WORKBENCH_VPC_ID")) or os.getenv("WORKBENCH_VPC_ID")
+subnet_ids = (cm and cm.get_config("WORKBENCH_SUBNET_IDS")) or os.getenv("WORKBENCH_SUBNET_IDS", "")
+
+# Log the configuration for transparency
+print("Configuration:")
+print(f"  WORKBENCH_BUCKET: {workbench_bucket}")
+print(f"  WORKBENCH_SSO_GROUP: {sso_group}")
+print(f"  WORKBENCH_ADDITIONAL_BUCKETS: {additional_buckets}")
+print(f"  WORKBENCH_VPC_ID: {existing_vpc_id}")
+print(f"  WORKBENCH_SUBNET_IDS: {subnet_ids}")
+
+# Our CDK App and Environment
+app = cdk.App()
+env = cdk.Environment(account=aws_account, region=aws_region)
+
+# Create the Workbench Core Stack
+sandbox_stack = WorkbenchCoreStack(
+    app,
+    "WorkbenchCore",
+    env=env,
+    props=WorkbenchCoreStackProps(
+        workbench_bucket=workbench_bucket,
+        sso_group=sso_group,
+        additional_buckets=additional_buckets,
+        existing_vpc_id=existing_vpc_id,
+        subnet_ids=subnet_ids,
+    ),
+)
+
+app.synth()

workbench-0.8.168/aws_setup/workbench_core/requirements.txt

@@ -0,0 +1,3 @@
+aws-cdk-lib>=2.211.0
+constructs>=10.4.2,<11.0.0
+boto3>=1.34.0

{workbench-0.8.166 → workbench-0.8.168}/aws_setup/workbench_core/workbench_core/workbench_core_stack.py

@@ -1,4 +1,12 @@
-from aws_cdk import Environment, Stack, aws_iam as iam, aws_logs as logs, RemovalPolicy
+from aws_cdk import (
+    Environment,
+    Stack,
+    aws_iam as iam,
+    aws_logs as logs,
+    aws_ec2 as ec2,
+    aws_batch as batch,
+    RemovalPolicy,
+)
 from constructs import Construct
 from typing import Any, List
 from dataclasses import dataclass, field
@@ -9,6 +17,8 @@ class WorkbenchCoreStackProps:
     workbench_bucket: str
     sso_group: str
     additional_buckets: List[str] = field(default_factory=list)
+    existing_vpc_id: str = None
+    subnet_ids: List[str] = field(default_factory=list)  # Optional subnets ids for the Batch compute environment
 
 
 class WorkbenchCoreStack(Stack):
@@ -21,7 +31,7 @@ class WorkbenchCoreStack(Stack):
         **kwargs: Any,
     ) -> None:
         desc = "Workbench Core: Defines the core Workbench resources, roles, and policies for the Workbench API."
-        super().__init__(scope, construct_id, description=desc, **kwargs)
+        super().__init__(scope, construct_id, env=env, description=desc, **kwargs)
 
         # Print the environment details
         print("Environment")
@@ -31,13 +41,15 @@ class WorkbenchCoreStack(Stack):
         self.workbench_bucket = props.workbench_bucket
         self.sso_group = props.sso_group
         self.additional_buckets = props.additional_buckets
+        self.existing_vpc_id = props.existing_vpc_id
+        self.subnet_ids = props.subnet_ids
 
         # Workbench Role Names
         self.execution_role_name = "Workbench-ExecutionRole"  # Main role
         self.readonly_role_name = "Workbench-ReadOnlyRole"  # Read only operations
         self.glue_role_name = "Workbench-GlueRole"
         self.lambda_role_name = "Workbench-LambdaRole"
-        self.training_role_name = "Workbench-TrainingRole"
+        self.batch_role_name = "Workbench-BatchRole"
 
         # Create the WorkbenchLogGroup for CloudWatch Logs
         self.workbench_log_group = logs.LogGroup(
@@ -64,6 +76,12 @@ class WorkbenchCoreStack(Stack):
         self.endpoint_read_policy = self.workbench_endpoint_read_policy()
         self.endpoint_policy = self.workbench_endpoint_policy()
         self.pipeline_policy = self.workbench_pipeline_policy()
+        self.dataframe_store_read_policy = self.workbench_dataframe_store_read_policy()
+        self.dataframe_store_full_policy = self.workbench_dataframe_store_full_policy()
+        self.parameter_store_read_policy = self.workbench_parameter_store_read_policy()
+        self.parameter_store_full_policy = self.workbench_parameter_store_full_policy()
+        self.inference_store_read_policy = self.workbench_inference_store_read_policy()
+        self.inference_store_full_policy = self.workbench_inference_store_full_policy()
 
         # Create our main Workbench API Execution Role
         self.workbench_execution_role = self.create_execution_role()
@@ -71,9 +89,14 @@ class WorkbenchCoreStack(Stack):
         # Create a read-only role for the Workbench API
         self.workbench_readonly_role = self.create_readonly_role()
 
-        # Create additional roles for Lambda and Glue
+        # Create additional roles for Lambda, Glue, and Batch
         self.workbench_lambda_role = self.create_lambda_role()
         self.workbench_glue_role = self.create_glue_role()
+        self.workbench_batch_role = self.create_batch_role()
+
+        # Batch Compute Environment and Job Queue
+        self.batch_compute_environment = self.create_batch_compute_environment()
+        self.batch_job_queue = self.create_batch_job_queue()
 
     ####################
     #    S3 Buckets    #
@@ -172,7 +195,7 @@ class WorkbenchCoreStack(Stack):
                 "glue:GetPartition",
                 "glue:GetPartitions",
             ],
-            resources=self._workbench_database_arns(),
+            resources=self._workbench_database_arns() + self._inference_database_arns(),
         )
 
     def glue_databases_full(self) -> iam.PolicyStatement:
@@ -185,16 +208,21 @@ class WorkbenchCoreStack(Stack):
                 "glue:UpdateTable",
                 "glue:DeleteTable",
             ],
-            resources=self._workbench_database_arns(),
+            resources=self._workbench_database_arns() + self._inference_database_arns(),
         )
 
     def _workbench_database_arns(self) -> list[str]:
-        """Helper to get all Workbench-managed database/table ARNs."""
+        """Helper to get Workbench-managed database/table ARNs."""
         return [
             f"arn:aws:glue:{self.region}:{self.account}:database/workbench",
             f"arn:aws:glue:{self.region}:{self.account}:table/workbench/*",
             f"arn:aws:glue:{self.region}:{self.account}:database/sagemaker_featurestore",
             f"arn:aws:glue:{self.region}:{self.account}:table/sagemaker_featurestore/*",
+        ]
+
+    def _inference_database_arns(self) -> list[str]:
+        """Helper to get inference store database/table ARNs."""
+        return [
             f"arn:aws:glue:{self.region}:{self.account}:database/inference_store",
             f"arn:aws:glue:{self.region}:{self.account}:table/inference_store/*",
         ]
@@ -274,10 +302,183 @@ class WorkbenchCoreStack(Stack):
         """Allows us to specify the Workbench-Glue role when creating a Glue Job"""
         return iam.PolicyStatement(
             actions=["iam:PassRole"],
-            resources=[f"arn:aws:iam::{self.account}:role/Workbench-GlueRole"],
+            resources=[f"arn:aws:iam::{self.account}:role/{self.glue_role_name}"],
             conditions={"StringEquals": {"iam:PassedToService": "glue.amazonaws.com"}},
         )
 
+    ##################
+    #   Batch Jobs   #
+    ##################
+    def batch_job_logs(self) -> iam.PolicyStatement:
+        """Create a policy statement for Glue job CloudWatch logs.
+
+        Returns:
+            iam.PolicyStatement: The policy statement for Glue job log interactions.
+        """
+        return iam.PolicyStatement(
+            actions=[
+                "logs:CreateLogGroup",
+                "logs:CreateLogStream",
+                "logs:PutLogEvents",
+            ],
+            resources=[
+                f"arn:aws:logs:{self.region}:{self.account}:log-group:/aws/batch/job",
+                f"arn:aws:logs:{self.region}:{self.account}:log-group:/aws/batch/job:*",
+            ],
+        )
+
+    @staticmethod
+    def batch_jobs_discover() -> iam.PolicyStatement:
+        """Discovery actions that absolutely require * resource."""
+        return iam.PolicyStatement(
+            actions=[
+                "batch:ListJobs",  # Requires * to list across all queues
+                "batch:DescribeJobs",  # Requires * even for specific job IDs (AWS API design)
+            ],
+            resources=["*"],
+        )
+
+    def batch_jobs_read(self) -> iam.PolicyStatement:
+        """Read-only access to specific Batch resources."""
+        return iam.PolicyStatement(
+            actions=[
+                "batch:DescribeJobDefinitions",
+                "batch:DescribeJobQueues",
+                "batch:DescribeComputeEnvironments",
+            ],
+            resources=[
+                f"arn:aws:batch:{self.region}:{self.account}:job-definition/workbench-*",
+                f"arn:aws:batch:{self.region}:{self.account}:job-queue/workbench-*",
+                f"arn:aws:batch:{self.region}:{self.account}:compute-environment/workbench-*",
+                f"arn:aws:batch:{self.region}:{self.account}:job/*",  # Job IDs are random UUIDs
+            ],
+        )
+
+    def batch_jobs_full(self) -> iam.PolicyStatement:
+        """Full access to specific Batch resources."""
+        read_statement = self.batch_jobs_read()
+        return iam.PolicyStatement(
+            actions=read_statement.actions
+            + [
+                "batch:RegisterJobDefinition",
+                "batch:DeregisterJobDefinition",
+                "batch:SubmitJob",
+                "batch:TerminateJob",
+                "batch:CancelJob",
+            ],
+            resources=read_statement.resources,
+        )
+
+    def batch_pass_role(self) -> iam.PolicyStatement:
+        """Allows us to specify the Workbench-Batch role when creating a Batch Job"""
+        return iam.PolicyStatement(
+            actions=["iam:PassRole"],
+            resources=[f"arn:aws:iam::{self.account}:role/{self.batch_role_name}"],
+            conditions={"StringEquals": {"iam:PassedToService": "ecs-tasks.amazonaws.com"}},
+        )
+
+    #####################
+    #   Batch Compute   #
+    #####################
+    def create_batch_compute_environment(self) -> batch.FargateComputeEnvironment:
+        """Create the Batch compute environment with Fargate."""
+
+        # Do we have an existing VPC we want to use? Otherwise use a default
+        if self.existing_vpc_id:
+            vpc = ec2.Vpc.from_lookup(self, "ImportedVPC", vpc_id=self.existing_vpc_id)
+        else:
+            vpc = ec2.Vpc.from_lookup(self, "DefaultVpc", is_default=True)
+
+        # Use specific subnets if provided, otherwise let CDK choose
+        vpc_subnets = None
+        if self.subnet_ids:
+            vpc_subnets = ec2.SubnetSelection(
+                subnets=[
+                    ec2.Subnet.from_subnet_id(self, f"BatchSubnet{i}", subnet_id)
+                    for i, subnet_id in enumerate(self.subnet_ids)
+                ]
+            )
+
+        return batch.FargateComputeEnvironment(
+            self,
+            "WorkbenchBatchComputeEnvironment",
+            compute_environment_name="workbench-compute-env",
+            vpc=vpc,
+            vpc_subnets=vpc_subnets,
+            replace_compute_environment=True,
+        )
+
+    def create_batch_job_queue(self) -> batch.JobQueue:
+        """Create the Batch job queue."""
+        return batch.JobQueue(
+            self,
+            "WorkbenchBatchJobQueue",
+            job_queue_name="workbench-job-queue",
+            compute_environments=[
+                batch.OrderedComputeEnvironment(compute_environment=self.batch_compute_environment, order=1)
+            ],
+        )
+
+    #####################
+    #  DataFrame Store  #
+    #####################
+    def dataframe_store_read(self) -> iam.PolicyStatement:
+        """Create a policy statement for reading from the DataFrame Store.
+
+        Returns:
+            iam.PolicyStatement: The policy statement for reading from the DataFrame Store.
+        """
+
+        # Just return the S3 read policy for the DataFrame Store
+        return self.s3_read()
+
+    def dataframe_store_full(self) -> iam.PolicyStatement:
+        """Create a policy statement for full access to the DataFrame Store.
+
+        Returns:
+            iam.PolicyStatement: The policy statement for full access to the DataFrame Store.
+        """
+
+        # Just return the S3 full policy for the DataFrame Store
+        return self.s3_full()
+
+    #####################
+    #  Inference Store  #
+    #####################
+    def inference_store_read(self) -> iam.PolicyStatement:
+        """Create a policy statement for reading from the Parameter Store.
+
+        Returns:
+            iam.PolicyStatement: The policy statement for reading from the Parameter Store.
+        """
+        return iam.PolicyStatement(
+            actions=[
+                "glue:GetDatabase",
+                "glue:GetTable",
+                "glue:GetTables",
+                "glue:GetPartition",
+                "glue:GetPartitions",
+            ],
+            resources=self._inference_database_arns(),
+        )
+
+    def inference_store_full(self) -> iam.PolicyStatement:
+        """Create a policy statement for full access to the Inference Store.
+
+        Returns:
+            iam.PolicyStatement: The policy statement for full access to the Inference Store.
+        """
+        read_statement = self.inference_store_read()
+        return iam.PolicyStatement(
+            actions=read_statement.actions
+            + [
+                "glue:CreateTable",
+                "glue:UpdateTable",
+                "glue:DeleteTable",
+            ],
+            resources=self._inference_database_arns(),
+        )
+
     ####################
     #  VPC/Networking  #
     ####################
@@ -1003,6 +1204,86 @@ class WorkbenchCoreStack(Stack):
             managed_policy_name="WorkbenchPipelinePolicy",
         )
 
+    def workbench_dataframe_store_read_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench DataFrame Store (READ-ONLY)"""
+        policy_statements = [
+            self.dataframe_store_read(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchDFStoreReadPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchDFStoreReadPolicy",
+        )
+
+    def workbench_dataframe_store_full_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench DataFrame Store (FULL)"""
+        policy_statements = [
+            self.dataframe_store_full(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchDFStoreFullPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchDFStorePolicy",
+        )
+
+    def workbench_parameter_store_read_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench Parameter Store (READ-ONLY)"""
+        policy_statements = [
+            self.parameter_store_discover(),
+            self.parameter_store_read(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchParameterStoreReadPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchParameterStoreReadPolicy",
+        )
+
+    def workbench_parameter_store_full_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench Parameter Store (FULL)"""
+        policy_statements = [
+            self.parameter_store_discover(),
+            self.parameter_store_full(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchParameterStoreFullPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchParameterStorePolicy",
+        )
+
+    def workbench_inference_store_read_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench Inference Store (READ-ONLY)"""
+        policy_statements = [
+            self.inference_store_read(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchInferenceStoreReadPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchInferenceStoreReadPolicy",
+        )
+
+    def workbench_inference_store_full_policy(self) -> iam.ManagedPolicy:
+        """Create a managed policy for the Workbench Inference Store (FULL)"""
+        policy_statements = [
+            self.inference_store_full(),
+        ]
+
+        return iam.ManagedPolicy(
+            self,
+            id="WorkbenchInferenceStoreFullPolicy",
+            statements=policy_statements,
+            managed_policy_name="WorkbenchInferenceStorePolicy",
+        )
+
     def create_execution_role(self) -> iam.Role:
         """Create the Workbench Execution Role for API-related tasks"""
         # Define the base assumed by principals with service principals
@@ -1024,9 +1305,12 @@ class WorkbenchCoreStack(Stack):
         )
 
         # Create and attach the Workbench managed policies to the role
-        api_execution_role.add_to_policy(self.glue_pass_role())
         api_execution_role.add_to_policy(self.glue_jobs_discover())
         api_execution_role.add_to_policy(self.glue_jobs_full())
+        api_execution_role.add_to_policy(self.glue_pass_role())
+        api_execution_role.add_to_policy(self.batch_jobs_discover())
+        api_execution_role.add_to_policy(self.batch_jobs_full())
+        api_execution_role.add_to_policy(self.batch_pass_role())
         api_execution_role.add_to_policy(self.parameter_store_discover())
         api_execution_role.add_to_policy(self.parameter_store_full())
         api_execution_role.add_to_policy(self.cloudwatch_monitor())
@@ -1107,6 +1391,27 @@ class WorkbenchCoreStack(Stack):
         glue_role.add_managed_policy(self.pipeline_policy)
         return glue_role
 
+    def create_batch_role(self) -> iam.Role:
+        """Create the Workbench Batch Role."""
+        batch_assumed_by = iam.ServicePrincipal("ecs-tasks.amazonaws.com")
+        batch_role = iam.Role(
+            self,
+            id=self.batch_role_name,
+            assumed_by=batch_assumed_by,
+            role_name=self.batch_role_name,
+        )
+
+        # Add policies for the Batch Role
+        batch_role.add_to_policy(self.batch_job_logs())
+        batch_role.add_to_policy(self.parameter_store_full())
+        batch_role.add_to_policy(self.dataframe_store_full())
+        batch_role.add_managed_policy(self.datasource_policy)
+        batch_role.add_managed_policy(self.featureset_policy)
+        batch_role.add_managed_policy(self.model_policy)
+        batch_role.add_managed_policy(self.endpoint_policy)
+        batch_role.add_managed_policy(self.pipeline_policy)
+        return batch_role
+
     def _create_sso_principals(self, base_principals: iam.CompositePrincipal = None) -> iam.CompositePrincipal:
         """
         Create principals with SSO trust relationship configuration.

workbench-0.8.168/model_docker_images/ml_pipelines/Dockerfile

@@ -0,0 +1,38 @@
+# Multi-stage build for dependency resolution
+FROM python:3.12-slim AS builder
+
+# Install build dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        build-essential \
+        gcc
+
+# Copy and install requirements file
+COPY requirements.txt /tmp/
+RUN pip install --no-cache-dir -r /tmp/requirements.txt
+
+# Final runtime image
+FROM python:3.12-slim
+
+# Install required X11 libraries for RDKit Draw module
+RUN apt-get update && apt-get install -y \
+    libxrender1 \
+    libxext6 \
+    libsm6 \
+    libxinerama1 \
+    libfontconfig1 \
+    libcairo2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy installed packages from builder
+COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+
+# Install workbench only
+RUN pip install --no-cache-dir workbench==0.8.167
+
+# Add the script runner
+COPY ml_pipeline_runner.py /app/ml_pipeline_runner.py
+WORKDIR /app
+
+ENTRYPOINT ["python", "/app/ml_pipeline_runner.py"]

workbench-0.8.168/model_docker_images/ml_pipelines/ml_pipeline_runner.py

@@ -0,0 +1,71 @@
+import os
+import sys
+import subprocess
+import boto3
+import logging
+from urllib.parse import urlparse
+import workbench
+
+# Set up logging
+log = logging.getLogger("workbench")
+
+
+def download_ml_pipeline_from_s3(s3_path: str, local_path: str):
+    """Download ML Pipeline from S3 to local filesystem."""
+    parsed = urlparse(s3_path)
+    bucket = parsed.netloc
+    key = parsed.path.lstrip("/")
+    log.info(f"Downloading {s3_path} to {local_path}")
+    s3_client = boto3.client("s3")
+    s3_client.download_file(bucket, key, local_path)
+
+
+def run_ml_pipeline(script_path: str):
+    """Execute the ML pipeline script."""
+    log.info(f"Executing ML pipeline: {script_path}")
+    try:
+        # Run the script with python
+        result = subprocess.run(
+            [sys.executable, script_path], check=False, text=True  # Don't raise exception on non-zero exit
+        )
+        if result.returncode == 0:
+            log.info("ML pipeline completed successfully")
+        else:
+            log.error(f"ML pipeline failed with exit code {result.returncode}")
+
+        return result.returncode
+    except Exception as e:
+        log.error(f"ML pipeline execution error: {e}")
+        return 1
+
+
+def main():
+    """Main entry point for the ML pipeline runner."""
+
+    # Report the version of the workbench package
+    log.info(f"Workbench version: {workbench.__version__}")
+
+    # Get the ML Pipeline S3 path from environment variable
+    ml_pipeline_s3_path = os.environ.get("ML_PIPELINE_S3_PATH")
+    if not ml_pipeline_s3_path:
+        log.error("ML_PIPELINE_S3_PATH environment variable not set")
+        sys.exit(1)
+
+    # Extract script name for local file
+    script_name = os.path.basename(ml_pipeline_s3_path)
+    local_script_path = f"/tmp/{script_name}"
+    try:
+        # Download the ML pipeline script from S3
+        download_ml_pipeline_from_s3(ml_pipeline_s3_path, local_script_path)
+        # Execute the ML pipeline
+        exit_code = run_ml_pipeline(local_script_path)
+        # Clean up
+        os.remove(local_script_path)
+        sys.exit(exit_code)
+    except Exception as e:
+        log.error(f"Error in run_script: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

workbench-0.8.168/model_docker_images/ml_pipelines/requirements.txt

@@ -0,0 +1,16 @@
+# This file is used to install the required packages for the PyTorch Training Docker image.
+--index-url https://download.pytorch.org/whl/cpu
+--extra-index-url https://pypi.org/simple/
+torch==2.8.0
+pandas==2.3.1
+awswrangler==3.12.1
+pytorch-tabular==1.1.1
+requests==2.32.4  # Needed by PyTorch-Tabular
+joblib==1.5.1
+boto3==1.40.14
+botocore==1.40.14
+redis==6.4.0
+scikit-learn==1.7.1
+xgboost==3.0.4
+rdkit==2025.3.5
+mordredcommunity==2.0.6

{workbench-0.8.166 → workbench-0.8.168}/model_docker_images/scripts/build_deploy.sh

@@ -14,6 +14,7 @@ declare -A REPO_MAP=(
   ["xgb_inference"]="aws-ml-images/py312-sklearn-xgb-inference"
   ["pytorch_training"]="aws-ml-images/py312-pytorch-training"
   ["pytorch_inference"]="aws-ml-images/py312-pytorch-inference"
+  ["ml_pipelines"]="aws-ml-images/py312-ml-pipelines"
   ["workbench_inference"]="aws-ml-images/py312-workbench-inference"
   ["meta_endpoint"]="aws-ml-images/py312-meta-endpoint"
 )
@@ -83,12 +84,12 @@ build_image() {
   echo -e "${YELLOW}Building image: $name ($platform)${NC}"
 
   if [ ! -f "$DIR/Dockerfile" ]; then
-    echo "❌ Error: Dockerfile not found in $DIR"
+    echo "❌  Error: Dockerfile not found in $DIR"
     exit 1
   fi
 
   docker build --platform $platform -t $name $DIR
-  echo -e "${GREEN}✅ Successfully built: $name${NC}"
+  echo -e "${GREEN}✅  Successfully built: $name${NC}"
 }
 
 # Helper function to check if an image exists in ECR
@@ -169,13 +170,13 @@ if [ "$IMAGE_TYPE" = "fixme" ]; then
 fi
 
 echo "======================================"
-echo -e "${GREEN}✅ Build completed successfully!${NC}"
+echo -e "${GREEN}✅  Build completed successfully!${NC}"
 echo "======================================"
 
 # Deploy if requested
 if [ "$DEPLOY" = true ]; then
   echo "======================================"
-  echo "🚀 Deploying $IMAGE_TYPE container to ECR"
+  echo "🚀  Deploying $IMAGE_TYPE container to ECR"
   echo "======================================"
 
   deploy_image "$IMAGE_VERSION"
@@ -186,14 +187,14 @@ if [ "$DEPLOY" = true ]; then
   fi
 
   echo "======================================"
-  echo -e "${GREEN}✅ Deployment complete!${NC}"
+  echo -e "${GREEN}✅  Deployment complete!${NC}"
   echo "======================================"
 else
   # Print information about the built image
   echo "Local build complete. Use --deploy to push the image to AWS ECR in regions: ${REGION_LIST[*]}."
 
   echo "======================================"
-  echo "📋 Image information:"
+  echo "📋  Image information:"
   echo "${IMAGE_TYPE^} image: $REPO_NAME:$IMAGE_VERSION"
 
   if [ "$IMAGE_TYPE" = "fixme" ]; then