workbench 0.8.167__py3-none-any.whl → 0.8.169__py3-none-any.whl

workbench/scripts/ml_pipeline_launcher.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from workbench.core.cloud_platform.aws.aws_account_clamp import AWSAccountClamp
 from workbench.utils.config_manager import ConfigManager
 from workbench.utils.s3_utils import upload_content_to_s3
+from workbench.utils.cloudwatch_utils import get_cloudwatch_logs_url
 
 log = logging.getLogger("workbench")
 cm = ConfigManager()
@@ -26,32 +27,42 @@ def get_batch_role_arn() -> str:
     return f"arn:aws:iam::{account_id}:role/Workbench-BatchRole"
 
 
-def ensure_job_definition():
-    """Ensure the job definition exists with network configuration."""
-    batch = AWSAccountClamp().boto3_session.client("batch")
-    name = "workbench-ml-pipeline-runner"
-
-    response = batch.register_job_definition(
-        jobDefinitionName=name,
-        type="container",
-        platformCapabilities=["FARGATE"],
-        containerProperties={
-            "image": get_ecr_image_uri(),
-            "resourceRequirements": [{"type": "VCPU", "value": "2"}, {"type": "MEMORY", "value": "4096"}],
-            "jobRoleArn": get_batch_role_arn(),
-            "executionRoleArn": get_batch_role_arn(),
-            "environment": [{"name": "WORKBENCH_BUCKET", "value": workbench_bucket}],
-            "networkConfiguration": {"assignPublicIp": "ENABLED"},  # This is required so the ECR image can be pulled
-        },
-        timeout={"attemptDurationSeconds": 10800},  # 3 hours
-    )
+def _log_cloudwatch_link(job: dict, message_prefix: str = "View logs") -> None:
+    """
+    Helper method to log CloudWatch logs link with clickable URL and full URL display.
+
+    Args:
+        job: Batch job description dictionary
+        message_prefix: Prefix for the log message (default: "View logs")
+    """
+    log_stream = job.get("container", {}).get("logStreamName")
+    logs_url = get_cloudwatch_logs_url(log_group="/aws/batch/job", log_stream=log_stream)
+    if logs_url:
+        clickable_url = f"\033]8;;{logs_url}\033\\{logs_url}\033]8;;\033\\"
+        log.info(f"{message_prefix}: {clickable_url}")
+    else:
+        log.info("Check AWS Batch console for logs")
+
+
+def run_batch_job(script_path: str, size: str = "small") -> int:
+    """
+    Submit and monitor an AWS Batch job for ML pipeline execution.
 
-    log.info(f"Job definition ready: {name} (revision {response['revision']})")
-    return name
+    Uploads script to S3, submits Batch job, monitors until completion or 2 minutes of RUNNING.
 
+    Args:
+        script_path: Local path to the ML pipeline script
+        size: Job size tier - "small" (default), "medium", or "large"
+          - small: 2 vCPU, 4GB RAM for lightweight processing
+          - medium: 4 vCPU, 8GB RAM for standard ML workloads
+          - large: 8 vCPU, 16GB RAM for heavy training/inference
+
+    Returns:
+        Exit code (0 for success/disconnected, non-zero for failure)
+    """
+    if size not in ["small", "medium", "large"]:
+        raise ValueError(f"Invalid size '{size}'. Must be 'small', 'medium', or 'large'")
 
-def run_batch_job(script_path: str) -> int:
-    """Upload script, submit job, and track to completion."""
     batch = AWSAccountClamp().boto3_session.client("batch")
     script_name = Path(script_path).stem
 
@@ -65,38 +76,55 @@ def run_batch_job(script_path: str) -> int:
     response = batch.submit_job(
         jobName=job_name,
         jobQueue="workbench-job-queue",
-        jobDefinition=ensure_job_definition(),
+        jobDefinition=f"workbench-ml-pipeline-{size}",
         containerOverrides={
             "environment": [
-                {"name": "SCRIPT_S3_PATH", "value": s3_path},
+                {"name": "ML_PIPELINE_S3_PATH", "value": s3_path},
                 {"name": "WORKBENCH_BUCKET", "value": workbench_bucket},
             ]
         },
     )
-
     job_id = response["jobId"]
-    log.info(f"Submitted job: {job_name} ({job_id})")
+    log.info(f"Submitted job: {job_name} ({job_id}) using {size} tier")
 
-    # Track job to completion
+    # Monitor job
+    last_status, running_start = None, None
     while True:
         job = batch.describe_jobs(jobs=[job_id])["jobs"][0]
         status = job["status"]
-        log.info(f"Job status: {status}")
 
+        if status != last_status:
+            log.info(f"Job status: {status}")
+            last_status = status
+            if status == "RUNNING":
+                running_start = time.time()
+
+        # Disconnect after 2 minutes of running
+        if status == "RUNNING" and running_start and (time.time() - running_start >= 120):
+            log.info("✅  ML Pipeline is running successfully!")
+            _log_cloudwatch_link(job, "📊  Monitor logs")
+            return 0
+
+        # Handle completion
         if status in ["SUCCEEDED", "FAILED"]:
             exit_code = job.get("attempts", [{}])[-1].get("exitCode", 1)
-            if status == "FAILED":
-                log.error(f"Job failed: {job.get('statusReason', 'Unknown reason')}")
+            msg = (
+                "Job completed successfully"
+                if status == "SUCCEEDED"
+                else f"Job failed: {job.get('statusReason', 'Unknown')}"
+            )
+            log.info(msg) if status == "SUCCEEDED" else log.error(msg)
+            _log_cloudwatch_link(job)
             return exit_code
 
-        time.sleep(30)
+        time.sleep(10)
 
 
 def main():
+    """CLI entry point for running ML pipelines on AWS Batch."""
     parser = argparse.ArgumentParser(description="Run ML pipeline script on AWS Batch")
     parser.add_argument("script_file", help="Local path to ML pipeline script")
     args = parser.parse_args()
-
     try:
         exit_code = run_batch_job(args.script_file)
         exit(exit_code)

workbench/scripts/monitor_cloud_watch.py

@@ -4,8 +4,10 @@ import sys
 import time
 import argparse
 from datetime import datetime, timedelta, timezone
-from workbench.core.cloud_platform.aws.aws_account_clamp import AWSAccountClamp
+
+# Workbench Imports
 from workbench.utils.repl_utils import cprint, Spinner
+from workbench.utils.cloudwatch_utils import get_cloudwatch_client, get_active_log_streams, stream_log_events
 
 # Define the log levels to include all log levels above the specified level
 log_level_map = {
@@ -33,64 +35,6 @@ def date_display(dt):
         return dt.strftime("%Y-%m-%d %I:%M%p") + "(UTC)"
 
 
-def get_cloudwatch_client():
-    """Get the CloudWatch Logs client using the Workbench assumed role session."""
-    session = AWSAccountClamp().boto3_session
-    return session.client("logs")
-
-
-def get_active_log_streams(client, log_group_name, start_time_ms, stream_filter=None):
-    """Retrieve log streams that have events after the specified start time."""
-
-    # Get all the streams in the log group
-    active_streams = []
-    stream_params = {
-        "logGroupName": log_group_name,
-        "orderBy": "LastEventTime",
-        "descending": True,
-    }
-
-    # Loop to retrieve all log streams (maximum 50 per call)
-    while True:
-        response = client.describe_log_streams(**stream_params)
-        log_streams = response.get("logStreams", [])
-
-        for log_stream in log_streams:
-            log_stream_name = log_stream["logStreamName"]
-            last_event_timestamp = log_stream.get("lastEventTimestamp")
-
-            # Include streams with events since the specified start time
-            # Note: There's some issue where the last event timestamp is 'off'
-            #       so we're going to add 60 minutes from the last event timestamp
-            last_event_timestamp += 60 * 60 * 1000
-            if last_event_timestamp >= start_time_ms:
-                active_streams.append(log_stream_name)
-            else:
-                break  # Stop if we reach streams older than the start time
-
-        # Check if there are more streams to retrieve
-        if "nextToken" in response:
-            stream_params["nextToken"] = response["nextToken"]
-        else:
-            break
-
-    # Sort and report the active log streams
-    active_streams.sort()
-    if active_streams:
-        print("Active log streams:", len(active_streams))
-
-    # Filter the active streams by a substring if provided
-    if stream_filter and active_streams:
-        print(f"Filtering active log streams by '{stream_filter}'...")
-        active_streams = [stream for stream in active_streams if stream_filter in stream]
-
-    for stream in active_streams:
-        print(f"\t - {stream}")
-
-    # Return the active log streams
-    return active_streams
-
-
 def get_latest_log_events(client, log_group_name, start_time, end_time=None, stream_filter=None):
     """Retrieve the latest log events from the active/filtered log streams in a CloudWatch Logs group."""
 
@@ -99,11 +43,15 @@ def get_latest_log_events(client, log_group_name, start_time, end_time=None, str
         get_latest_log_events.first_run = True
 
     log_events = []
-    start_time_ms = int(start_time.timestamp() * 1000)  # Convert start_time to milliseconds
+    start_time_ms = int(start_time.timestamp() * 1000)
+
+    # Use the util function to get active streams
+    active_streams = get_active_log_streams(log_group_name, start_time_ms, stream_filter, client)
 
-    # Get the active log streams with events since start_time
-    active_streams = get_active_log_streams(client, log_group_name, start_time_ms, stream_filter)
     if active_streams:
+        print(f"Active log streams: {len(active_streams)}")
+        for stream in active_streams:
+            print(f"\t - {stream}")
         print(f"Processing log events from {date_display(start_time)} on {len(active_streams)} active log streams...")
         get_latest_log_events.first_run = False
     else:
@@ -114,50 +62,22 @@ def get_latest_log_events(client, log_group_name, start_time, end_time=None, str
             print("Monitoring for new events...")
         return log_events
 
-    # Iterate over the active streams and fetch log events
+    # Use the util function to stream events from each log stream
     for log_stream_name in active_streams:
-        params = {
-            "logGroupName": log_group_name,
-            "logStreamName": log_stream_name,
-            "startTime": start_time_ms,  # Use start_time in milliseconds
-            "startFromHead": True,  # Start from the nearest event to start_time
-        }
-        next_event_token = None
-        if end_time is not None:
-            params["endTime"] = int(end_time.timestamp() * 1000)
-
-        # Process the log events from this log stream
         spinner = Spinner("lightpurple", f"Pulling events from {log_stream_name}:")
         spinner.start()
         log_stream_events = 0
 
-        # Get the log events for the active log stream
-        while True:
-            if next_event_token:
-                params["nextToken"] = next_event_token
-                params.pop("startTime", None)  # Remove startTime when using nextToken
+        # Stream events using the util function
+        for event in stream_log_events(
+            log_group_name, log_stream_name, start_time, end_time, follow=False, client=client
+        ):
+            log_stream_events += 1
+            log_events.append(event)
 
-            # Fetch the log events (this call takes a while: optimize if we can)
-            events_response = client.get_log_events(**params)
+        spinner.stop()
+        print(f"Processed {log_stream_events} events from {log_stream_name} (Total: {len(log_events)})")
 
-            events = events_response.get("events", [])
-            for event in events:
-                event["logStreamName"] = log_stream_name
-
-            # Add the log stream events to our list of all log events
-            log_stream_events += len(events)
-            log_events.extend(events)
-
-            # Handle pagination for log events
-            next_event_token = events_response.get("nextForwardToken")
-
-            # Break the loop if there are no more events to fetch
-            if not next_event_token or next_event_token == params.get("nextToken"):
-                spinner.stop()
-                print(f"Processed {log_stream_events} events from {log_stream_name} (Total: {len(log_events)})")
-                break
-
-    # Return the log events
     return log_events
 
 
@@ -206,6 +126,7 @@ def monitor_log_group(
     print(f"Monitoring log group: {log_group_name} from {date_display(start_time)}")
     print(f"Log levels: {log_levels}")
     print(f"Search terms: {search_terms}")
+
     while True:
         # Get the latest log events with stream filtering if provided
         all_log_events = get_latest_log_events(client, log_group_name, start_time, end_time, stream_filter)
@@ -218,7 +139,6 @@ def monitor_log_group(
 
                 # Check the search terms
                 if not search_terms or any(term in event["message"].lower() for term in search_terms):
-
                     # Calculate the start and end index for this match
                     start_index = max(i - before, 0)
                     end_index = min(i + after, len(all_log_events) - 1)

workbench/utils/cloudwatch_utils.py

@@ -0,0 +1,137 @@
+"""AWS CloudWatch utility functions for Workbench."""
+
+import time
+import logging
+from datetime import datetime, timezone
+from typing import List, Optional, Dict, Generator
+from urllib.parse import quote
+from workbench.core.cloud_platform.aws.aws_account_clamp import AWSAccountClamp
+
+log = logging.getLogger("workbench")
+
+
+def get_cloudwatch_client():
+    """Get the CloudWatch Logs client using the Workbench assumed role session."""
+    session = AWSAccountClamp().boto3_session
+    return session.client("logs")
+
+
+def get_cloudwatch_logs_url(log_group: str, log_stream: str) -> Optional[str]:
+    """
+    Generate CloudWatch logs URL for the specified log group and stream.
+
+    Args:
+        log_group: Log group name (e.g., '/aws/batch/job')
+        log_stream: Log stream name
+
+    Returns:
+        CloudWatch console URL or None if unable to generate
+    """
+    try:
+        region = AWSAccountClamp().region
+
+        # URL encode the log group and stream
+        encoded_group = quote(log_group, safe="")
+        encoded_stream = quote(log_stream, safe="")
+
+        return (
+            f"https://{region}.console.aws.amazon.com/cloudwatch/home?"
+            f"region={region}#logsV2:log-groups/log-group/{encoded_group}"
+            f"/log-events/{encoded_stream}"
+        )
+    except Exception as e:  # noqa: BLE001
+        log.warning(f"Failed to generate CloudWatch logs URL: {e}")
+        return None
+
+
+def get_active_log_streams(
+    log_group_name: str, start_time_ms: int, stream_filter: Optional[str] = None, client=None
+) -> List[str]:
+    """Retrieve log streams that have events after the specified start time."""
+    if not client:
+        client = get_cloudwatch_client()
+    active_streams = []
+    stream_params = {
+        "logGroupName": log_group_name,
+        "orderBy": "LastEventTime",
+        "descending": True,
+    }
+    while True:
+        response = client.describe_log_streams(**stream_params)
+        log_streams = response.get("logStreams", [])
+        for log_stream in log_streams:
+            log_stream_name = log_stream["logStreamName"]
+            last_event_timestamp = log_stream.get("lastEventTimestamp", 0)
+            if last_event_timestamp >= start_time_ms:
+                active_streams.append(log_stream_name)
+            else:
+                break
+        if "nextToken" in response:
+            stream_params["nextToken"] = response["nextToken"]
+        else:
+            break
+    # Sort and filter streams
+    active_streams.sort()
+    if stream_filter and active_streams:
+        active_streams = [stream for stream in active_streams if stream_filter in stream]
+    return active_streams
+
+
+def stream_log_events(
+    log_group_name: str,
+    log_stream_name: str,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None,
+    follow: bool = False,
+    client=None,
+) -> Generator[Dict, None, None]:
+    """
+    Stream log events from a specific log stream.
+    Yields:
+        Log events as dictionaries
+    """
+    if not client:
+        client = get_cloudwatch_client()
+    params = {"logGroupName": log_group_name, "logStreamName": log_stream_name, "startFromHead": True}
+    if start_time:
+        params["startTime"] = int(start_time.timestamp() * 1000)
+    if end_time:
+        params["endTime"] = int(end_time.timestamp() * 1000)
+    next_token = None
+    while True:
+        if next_token:
+            params["nextToken"] = next_token
+            params.pop("startTime", None)
+        try:
+            response = client.get_log_events(**params)
+            events = response.get("events", [])
+            for event in events:
+                event["logStreamName"] = log_stream_name
+                yield event
+            next_token = response.get("nextForwardToken")
+            # Break if no more events or same token
+            if not next_token or next_token == params.get("nextToken"):
+                if not follow:
+                    break
+                time.sleep(2)
+        except client.exceptions.ResourceNotFoundException:
+            if not follow:
+                break
+            time.sleep(2)
+
+
+def print_log_event(
+    event: dict, show_stream: bool = True, local_time: bool = True, custom_format: Optional[str] = None
+):
+    """Print a formatted log event."""
+    timestamp = datetime.fromtimestamp(event["timestamp"] / 1000, tz=timezone.utc)
+    if local_time:
+        timestamp = timestamp.astimezone()
+    message = event["message"].rstrip()
+    if custom_format:
+        # Allow custom formatting
+        print(custom_format.format(stream=event.get("logStreamName", ""), time=timestamp, message=message))
+    elif show_stream and "logStreamName" in event:
+        print(f"[{event['logStreamName']}] [{timestamp:%Y-%m-%d %I:%M%p}] {message}")
+    else:
+        print(f"[{timestamp:%H:%M:%S}] {message}")

{workbench-0.8.167.dist-info → workbench-0.8.169.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.167
+Version: 0.8.169
 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.167.dist-info → workbench-0.8.169.dist-info}/RECORD

@@ -167,8 +167,8 @@ workbench/resources/open_source_api.key,sha256=3S0OTblsmC0msUPdE_dbBmI83xJNmYscu
 workbench/resources/signature_verify_pub.pem,sha256=V3-u-3_z2PH-805ybkKvzDOBwAbvHxcKn0jLBImEtzM,272
 workbench/scripts/check_double_bond_stereo.py,sha256=p5hnL54Weq77ES0HCELq9JeoM-PyUGkvVSeWYF2dKyo,7776
 workbench/scripts/glue_launcher.py,sha256=bIKQvfGxpAhzbeNvTnHfRW_5kQhY-169_868ZnCejJk,10692
-workbench/scripts/ml_pipeline_launcher.py,sha256=AJF7An1fMdyj3SNPHnGE__NuR89vtPeszqGw6WInGt4,3712
-workbench/scripts/monitor_cloud_watch.py,sha256=5QODOSVmfunf6L-gtK1dhW93z9ZbMy2UEsuyR2tij5E,12463
+workbench/scripts/ml_pipeline_launcher.py,sha256=fjI35SXi9CDSQ6Lan7qGcLAHkVCDioyhbPlo0eDHDxQ,4913
+workbench/scripts/monitor_cloud_watch.py,sha256=s7MY4bsHts0nup9G0lWESCvgJZ9Mw1Eo-c8aKRgLjMw,9235
 workbench/scripts/redis_expire.py,sha256=DxI_RKSNlrW2BsJZXcsSbaWGBgPZdPhtzHjV9SUtElE,1120
 workbench/scripts/redis_report.py,sha256=iaJSuGPyLCs6e0TMcZDoT0YyJ43xJ1u74YD8FLnnUg4,990
 workbench/scripts/show_config.py,sha256=ff2wIKIlOktoitcrhk2r2B4I4N_ynXkEHB11l5nn0nA,548
@@ -199,6 +199,7 @@ workbench/utils/bulk_utils.py,sha256=s1lYN2Uk536MNGetekLYL_VL0N34hUjk1FX9BAz3Qu0
 workbench/utils/cache.py,sha256=0R5RXYEz_XHARK3anmQC4VRMawMks_cJ8S4vwC2roAE,5524
 workbench/utils/chem_utils.py,sha256=tLTAvLKTOiYSzbVQF0M8V5-ej36IVgr21CNB2vVJjYQ,56780
 workbench/utils/cloudwatch_handler.py,sha256=t0L280Qa1nMq95dwnf8lB5g8FHrQAyGY5S4JwP3yIa8,5165
+workbench/utils/cloudwatch_utils.py,sha256=wXSqKcJlSnHyC0D6d4RsH8wwmx_0CsffcetUgXlZ_78,4828
 workbench/utils/color_utils.py,sha256=TmDGLK44t975lkfjt_1O-ee02QxrKfke7vPuXb-V-Uo,11779
 workbench/utils/config_manager.py,sha256=SBBmO1RGCQ_Zyh91tDxL1HOm5B0v38ImlLnOsEKzXPU,17649
 workbench/utils/dashboard_metrics.py,sha256=cNFI0GIAjd_IiDzM1oebsJ2QkRZuW068W_66ZC3J100,7398
@@ -275,9 +276,9 @@ workbench/web_interface/page_views/main_page.py,sha256=X4-KyGTKLAdxR-Zk2niuLJB2Y
 workbench/web_interface/page_views/models_page_view.py,sha256=M0bdC7bAzLyIaE2jviY12FF4abdMFZmg6sFuOY_LaGI,2650
 workbench/web_interface/page_views/page_view.py,sha256=Gh6YnpOGlUejx-bHZAf5pzqoQ1H1R0OSwOpGhOBO06w,455
 workbench/web_interface/page_views/pipelines_page_view.py,sha256=v2pxrIbsHBcYiblfius3JK766NZ7ciD2yPx0t3E5IJo,2656
-workbench-0.8.167.dist-info/licenses/LICENSE,sha256=z4QMMPlLJkZjU8VOKqJkZiQZCEZ--saIU2Z8-p3aVc0,1080
-workbench-0.8.167.dist-info/METADATA,sha256=RYkpkQ2sNwdHY4IPmFBH_3UcW-zKAZaonN2hVc_FTuc,9210
-workbench-0.8.167.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-workbench-0.8.167.dist-info/entry_points.txt,sha256=V_v6hQ4DYoCJnTnqbm036reCri_CXkA_ONcRSuF5OKg,305
-workbench-0.8.167.dist-info/top_level.txt,sha256=Dhy72zTxaA_o_yRkPZx5zw-fwumnjGaeGf0hBN3jc_w,10
-workbench-0.8.167.dist-info/RECORD,,
+workbench-0.8.169.dist-info/licenses/LICENSE,sha256=z4QMMPlLJkZjU8VOKqJkZiQZCEZ--saIU2Z8-p3aVc0,1080
+workbench-0.8.169.dist-info/METADATA,sha256=AoOujKSh6ueEHjNLcz8g5UMWZr5bGZrzk-ycBaw62n0,9210
+workbench-0.8.169.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+workbench-0.8.169.dist-info/entry_points.txt,sha256=V_v6hQ4DYoCJnTnqbm036reCri_CXkA_ONcRSuF5OKg,305
+workbench-0.8.169.dist-info/top_level.txt,sha256=Dhy72zTxaA_o_yRkPZx5zw-fwumnjGaeGf0hBN3jc_w,10
+workbench-0.8.169.dist-info/RECORD,,