sagemaker-hyperpod 3.0.2__tar.gz → 3.1.0__tar.gz

{sagemaker_hyperpod-3.0.2/src/sagemaker_hyperpod.egg-info → sagemaker_hyperpod-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sagemaker-hyperpod
-Version: 3.0.2
+Version: 3.1.0
 Summary: Amazon SageMaker HyperPod SDK and CLI
 Home-page: https://github.com/aws/sagemaker-hyperpod-cli
 Author: Amazon Web Services

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 dynamic = ["dependencies"]
 name = "sagemaker-hyperpod"
-version = "3.0.2"
+version = "3.1.0"
 description = "Amazon SageMaker HyperPod SDK and CLI"
 readme = "README.md"
 requires-python = ">=3.8"

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/setup.py

@@ -47,7 +47,7 @@ for root, dirs, files in os.walk(
 setup(
     data_files=sagemaker_hyperpod_recipes,
     name="sagemaker-hyperpod",
-    version="3.0.2",
+    version="3.1.0",
     description="Amazon SageMaker HyperPod SDK and CLI",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/cli/commands/training.py

@@ -1,16 +1,7 @@
 import click
-import logging
-import os
-import yaml
-import shutil
-import subprocess
-from pathlib import Path
 from sagemaker.hyperpod.training.hyperpod_pytorch_job import HyperPodPytorchJob
 from sagemaker.hyperpod.common.config import Metadata
-import tempfile
-from typing import List, Dict, Any, Optional, Callable, get_args, get_origin, Literal
 from sagemaker.hyperpod.cli.training_utils import generate_click_command
-from importlib.metadata import entry_points
 from hyperpod_pytorch_job_template.registry import SCHEMA_REGISTRY
 from sagemaker.hyperpod.common.telemetry.telemetry_logging import (
     _hyperpod_telemetry_emitter,
@@ -33,11 +24,17 @@ def pytorch_create(version, debug, config):
         job_name = config.get("name")
         namespace = config.get("namespace")
         spec = config.get("spec")
+        metadata_labels = config.get("labels")
+        annotations = config.get("annotations")
 
         # Prepare metadata
         metadata_kwargs = {"name": job_name}
         if namespace:
             metadata_kwargs["namespace"] = namespace
+        if metadata_labels:
+            metadata_kwargs["labels"] = metadata_labels
+        if annotations:
+            metadata_kwargs["annotations"] = annotations
 
         # Prepare job kwargs
         job_kwargs = {
@@ -163,6 +160,8 @@ def pytorch_describe(job_name: str, namespace: str):
         click.echo("=" * 80)
         click.echo(f"Name:           {job.metadata.name}")
         click.echo(f"Namespace:      {job.metadata.namespace}")
+        click.echo(f"Labels:         {job.metadata.labels}")
+        click.echo(f"Annotations:    {job.metadata.annotations}")
 
         # Print Spec details
         click.echo("\nSpec:")

sagemaker_hyperpod-3.1.0/src/sagemaker/hyperpod/cli/common_utils.py

@@ -0,0 +1,71 @@
+import sys
+from typing import Mapping, Type
+import click
+import pkgutil
+import json
+
+JUMPSTART_SCHEMA = "hyperpod_jumpstart_inference_template"
+CUSTOM_SCHEMA = "hyperpod_custom_inference_template"
+JUMPSTART_COMMAND = "hyp-jumpstart-endpoint"
+CUSTOM_COMMAND = "hyp-custom-endpoint"
+PYTORCH_SCHEMA="hyperpod_pytorch_job_template"
+PYTORCH_COMMAND="hyp-pytorch-job"
+
+
+def extract_version_from_args(registry: Mapping[str, Type], schema_pkg: str, default: str) -> str:
+    if "--version" not in sys.argv:
+        return default
+
+    idx = sys.argv.index("--version")
+    if idx + 1 >= len(sys.argv):
+        return default
+
+    requested_version = sys.argv[idx + 1]
+    invoked_command = next(
+        (arg for arg in sys.argv if arg.startswith('hyp-')),
+        None
+    )
+
+    # Check if schema validation is needed
+    needs_validation = (
+        (schema_pkg == JUMPSTART_SCHEMA and invoked_command == JUMPSTART_COMMAND) or
+        (schema_pkg == CUSTOM_SCHEMA and invoked_command == CUSTOM_COMMAND) or
+        (schema_pkg == PYTORCH_SCHEMA and invoked_command == PYTORCH_COMMAND)
+    )
+
+    if registry is not None and requested_version not in registry:
+        if needs_validation:
+                raise click.ClickException(f"Unsupported schema version: {requested_version}")
+        else:
+            return default
+
+    return requested_version
+
+
+def get_latest_version(registry: Mapping[str, Type]) -> str:
+    """
+    Get the latest version from the schema registry.
+    """
+    if not registry:
+        raise ValueError("Schema registry is empty")
+
+    # Sort versions and return the last (highest) one
+    sorted_versions = sorted(registry.keys(), key=lambda v: [int(x) for x in v.split('.')])
+    return sorted_versions[-1]
+
+
+def load_schema_for_version(
+    version: str,
+    base_package: str,
+) -> dict:
+    """
+    Load schema.json from the top-level <base_package>.vX_Y_Z package.
+    """
+    ver_pkg = f"{base_package}.v{version.replace('.', '_')}"
+    raw = pkgutil.get_data(ver_pkg, "schema.json")
+    if raw is None:
+        raise click.ClickException(
+            f"Could not load schema.json for version {version} "
+            f"(looked in package {ver_pkg})"
+        )
+    return json.loads(raw)

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/cli/inference_utils.py

@@ -2,25 +2,21 @@ import json
 import pkgutil
 import click
 from typing import Callable, Optional, Mapping, Type
-
-
-def load_schema_for_version(version: str, schema_pkg: str) -> dict:
-    ver_pkg = f"{schema_pkg}.v{version.replace('.', '_')}"
-    raw = pkgutil.get_data(ver_pkg, "schema.json")
-    if raw is None:
-        raise click.ClickException(f"Could not load schema.json for version {version}")
-    return json.loads(raw)
+import sys
+from sagemaker.hyperpod.cli.common_utils import extract_version_from_args, get_latest_version, load_schema_for_version
 
 
 def generate_click_command(
     *,
-    version_key: Optional[str] = None,
     schema_pkg: str = "hyperpod_jumpstart_inference_template",
     registry: Mapping[str, Type] = None,
 ) -> Callable:
     if registry is None:
         raise ValueError("You must pass a registry mapping version→Model")
 
+    default_version = get_latest_version(registry)
+    version = extract_version_from_args(registry, schema_pkg, default_version)
+
     def decorator(func: Callable) -> Callable:
         # Parser for the single JSON‐dict env var flag
         def _parse_json_flag(ctx, param, value):
@@ -34,7 +30,7 @@ def generate_click_command(
         # 1) the wrapper click actually invokes
         def wrapped_func(*args, **kwargs):
             namespace = kwargs.pop("namespace", None)
-            version = version_key or kwargs.pop("version", "1.0")
+            pop_version = kwargs.pop("version", "1.0")
 
             Model = registry.get(version)
             if Model is None:
@@ -81,7 +77,7 @@ def generate_click_command(
         )(wrapped_func)
 
         # 3) auto-inject all schema.json fields
-        schema = load_schema_for_version(version_key or "1.0", schema_pkg)
+        schema = load_schema_for_version(version, schema_pkg)
         props = schema.get("properties", {})
         reqs = set(schema.get("required", []))
 

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/cli/training_utils.py

@@ -3,29 +3,13 @@ import pkgutil
 import click
 from typing import Callable, Optional, Mapping, Type, Dict, Any
 from pydantic import ValidationError
-
-
-def load_schema_for_version(
-    version: str,
-    base_package: str,
-) -> dict:
-    """
-    Load schema.json from the top-level <base_package>.vX_Y_Z package.
-    """
-    ver_pkg = f"{base_package}.v{version.replace('.', '_')}"
-    raw = pkgutil.get_data(ver_pkg, "schema.json")
-    if raw is None:
-        raise click.ClickException(
-            f"Could not load schema.json for version {version} "
-            f"(looked in package {ver_pkg})"
-        )
-    return json.loads(raw)
+import sys
+from sagemaker.hyperpod.cli.common_utils import extract_version_from_args, get_latest_version, load_schema_for_version
 
 
 def generate_click_command(
     *,
-    version_key: Optional[str] = None,
-    schema_pkg: str,
+    schema_pkg: str = "hyperpod_pytorch_job_template",
     registry: Mapping[str, Type] = None,
 ) -> Callable:
     """
@@ -33,13 +17,15 @@ def generate_click_command(
       1) Injects click.options from the JSON Schema under `schema_pkg`
       2) At runtime, pops `version`, builds the flat model from `registry`, calls .to_domain()
       3) Finally invokes your handler as `func(version, domain_config)`
-    - `version_key`: if given, hard-codes the version (no --version flag injected)
     - `schema_pkg`: the importable package root to read schema.json from
     - `registry`: a dict mapping version → flat‐model class, e.g. hyperpod_pytorch_job_template.registry.SCHEMA_REGISTRY
     """
     if registry is None:
         raise ValueError("You must pass a registry mapping version→Model")
 
+    default_version = get_latest_version(registry)
+    version = extract_version_from_args(registry, schema_pkg, default_version)
+
     def decorator(func: Callable) -> Callable:
         # Parser for the single JSON‐dict env var flag
         def _parse_json_flag(ctx, param, value):
@@ -81,7 +67,7 @@ def generate_click_command(
         # 1) the wrapper click will call
         def wrapped_func(*args, **kwargs):
             # extract version
-            version = version_key or kwargs.pop("version", "1.0")
+            pop_version = kwargs.pop("version", default_version)
             debug = kwargs.pop("debug", False)
 
             # look up the model class
@@ -165,7 +151,7 @@ def generate_click_command(
             ]
         )
 
-        schema = load_schema_for_version(version_key or "1.0", schema_pkg)
+        schema = load_schema_for_version(version, schema_pkg)
         props = schema.get("properties", {})
         reqs = set(schema.get("required", []))
 
@@ -195,15 +181,6 @@ def generate_click_command(
                 help=spec.get("description", ""),
             )(wrapped_func)
 
-        # 3) if no hard-coded version_key, inject the top-level --version flag
-        if version_key is None:
-            wrapped_func = click.option(
-                "--version",
-                default="1.0",
-                show_default=True,
-                help="Schema version to use",
-            )(wrapped_func)
-
         return wrapped_func
 
     return decorator

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/common/config/metadata.py

@@ -16,3 +16,7 @@ class Metadata(BaseModel):
         default=None,
         description="Labels are key value pairs that are attached to objects, such as Pod. Labels are intended to be used to specify identifying attributes of objects. The system ignores labels that are not in the service's selector. Labels can only be added to objects during creation.",
     )
+    annotations: Optional[Dict[str, str]] = Field(
+        default=None,
+        description="Annotations are key-value pairs that can be used to attach arbitrary non-identifying metadata to objects.",
+    )

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/common/utils.py

@@ -1,21 +1,21 @@
-from kubernetes import client
+from kubernetes import client, __version__ as kubernetes_client_version
 from pydantic import ValidationError
 from kubernetes.client.exceptions import ApiException
 from kubernetes import config
 import re
 import boto3
 import json
-from typing import List
+from typing import List, Tuple, Optional
 import logging
 import os
 import subprocess
 import yaml
-from typing import Optional
 from kubernetes.config import (
     KUBE_CONFIG_DEFAULT_LOCATION,
 )
 
 EKS_ARN_PATTERN = r"arn:aws:eks:([\w-]+):\d+:cluster/([\w-]+)"
+CLIENT_VERSION_PATTERN = r'^\d+\.\d+\.\d+$'
 
 KUBE_CONFIG_PATH = os.path.expanduser(KUBE_CONFIG_DEFAULT_LOCATION)
 
@@ -297,3 +297,168 @@ def get_current_region():
         return get_region_from_eks_arn(eks_arn)
     except:
         return boto3.session.Session().region_name
+
+
+def parse_client_kubernetes_version(version_str: str) -> Tuple[int, int]:
+    """Parse major and minor version from client library version string.
+    
+    Handles both old versioning scheme (v12 and before) and new homogenized scheme.
+    Old scheme: v12.0.0 corresponds to Kubernetes v1.16
+    New scheme: v17.0.0 corresponds to Kubernetes v1.17
+    
+    Args:
+        version_str (str): Client library version string (e.g., '12.0.0', '17.0.0', 'v12.0.0')
+        
+    Returns:
+        Tuple[int, int]: Major and minor version numbers as (1, minor)
+    """
+    if not version_str:
+        logger = logging.getLogger(__name__)
+        logger.debug(f"Empty version string provided, Using default version 0.0")
+        return 0, 0
+    
+    # Remove suffix (like '+snapshot') if present
+    version_str = version_str.split('+')[0]
+    
+    # Remove 'v' prefix if present
+    if version_str.startswith('v'):
+        version_str = version_str[1:]
+    
+    # Client library version format (x.y.z)
+    if re.match(CLIENT_VERSION_PATTERN, version_str):
+        major = int(version_str.split('.')[0])
+        
+        # Old client versioning scheme (v12 and before)
+        if major <= 12:
+            # Currently maps to Kubernetes v1.x
+            # This mapping assumes Kubernetes major version is 1
+            # If Kubernetes moves to v2.x in the future, this mapping would need to be updated
+            return 1, major + 4
+        
+        # New homogenized scheme (v17 and above)
+        # Currently maps to Kubernetes v1.x
+        # This mapping assumes Kubernetes major version is 1
+        # If Kubernetes moves to v2.x in the future, this mapping would need to be updated
+        return 1, major
+    
+    # If we get here, parsing failed
+    logger = logging.getLogger(__name__)
+    logger.warning(f"Failed to parse client version from string: '{version_str}'. Using default version 0.0.")
+    return 0, 0
+
+
+
+def is_kubernetes_version_compatible(client_version: Tuple[int, int], server_version: Tuple[int, int]) -> bool:
+    """
+    Check if Kubernetes client and server versions are compatible.
+    
+    Args:
+        client_version (Tuple[int, int]): Client major and minor version
+        server_version (Tuple[int, int]): Server major and minor version
+        
+    Returns:
+        bool: True if versions are compatible, False otherwise
+    """
+    # Check for default versions (0.0) which indicate parsing failures
+    if client_version == (0, 0) or server_version == (0, 0):
+        logger = logging.getLogger(__name__)
+        logger.warning(
+            f"Version compatibility check using default version(s): client={client_version}, server={server_version}. "
+            f"\nThis may indicate a version parsing issue. Please check your Kubernetes configuration."
+        )
+        return True
+    
+    if client_version[0] != server_version[0]:
+        return False
+    
+    """
+        Client version should not be more than 3 minor versions behind the server and not more than 
+        1 minor version ahead of the server
+    """
+    client_minor = client_version[1]
+    server_minor = server_version[1]
+    
+    if server_minor - client_minor > 3:
+        return False
+        
+    if client_minor - server_minor > 1:
+        return False
+        
+    return True
+
+
+def verify_kubernetes_version_compatibility(logger) -> bool:
+    """
+    Verify compatibility between Kubernetes client and server versions.
+    
+    This function checks if the current Kubernetes client version is compatible with
+    the server version. It handles both minimum compatibility versions specified by
+    the server and the standard Kubernetes support policy (within 3 minor versions behind
+    and not more than 1 minor version ahead).
+
+    Ref link: https://github.com/kubernetes-client/python#compatibility
+    
+    Args:
+        logger: Logger instance for outputting messages.
+        
+    Returns:
+        bool: True if versions are compatible, False otherwise
+    """
+    
+    try:
+        version_api = client.VersionApi()
+        server_version_info = version_api.get_code()
+        
+        server_version_str = f"{server_version_info.major}.{server_version_info.minor}"
+        client_version = parse_client_kubernetes_version(kubernetes_client_version)
+        client_version_str = f"{client_version[0]}.{client_version[1]}"
+
+        # Debug output of server version info
+        logger.debug(f"Server version info: {server_version_info}")
+        logger.debug(f"Client version: {kubernetes_client_version}, parsed as {client_version_str}")
+        
+        # Check if server provides minimum compatibility versions (these are optional strings)
+        has_min_compatibility = False
+        is_compatible = True
+        
+        try:
+            if hasattr(server_version_info, 'min_compatibility_major') and server_version_info.min_compatibility_major is not None and \
+               hasattr(server_version_info, 'min_compatibility_minor') and server_version_info.min_compatibility_minor is not None:
+                min_major = int(server_version_info.min_compatibility_major)
+                min_minor = int(server_version_info.min_compatibility_minor)
+                has_min_compatibility = True
+                
+                # Check if client version is below minimum compatibility
+                if client_version[0] < min_major or (client_version[0] == min_major and client_version[1] < min_minor):
+                    logger.warning(
+                        f"Kubernetes version incompatibility detected! Your client version {client_version_str} "
+                        f"(package: {kubernetes_client_version}) is below the minimum compatible version {min_major}.{min_minor} "
+                        f"required by server {server_version_str}. The server explicitly requires a minimum client version."
+                    )
+                    logger.warning(
+                        f"To resolve this issue, please update your kubernetes Python client to meet the minimum requirement."
+                    )
+                    is_compatible = False
+        except (ValueError, TypeError, AttributeError) as e:
+            logger.debug(f"Could not parse minimum compatibility version: {e}")
+            has_min_compatibility = False
+            
+        if not has_min_compatibility:
+            # Fall back to standard compatibility check if min versions not provided
+            server_version_parsed = (int(server_version_info.major), int(server_version_info.minor))
+            if not is_kubernetes_version_compatible(client_version, server_version_parsed):
+                logger.warning(
+                    f"Kubernetes version incompatibility detected! Your client version {client_version_str} "
+                    f"(package: {kubernetes_client_version}) is not compatible with server version {server_version_str}. "
+                    f"According to Kubernetes support policy, client should be within 3 minor versions behind "
+                    f"and not more than 1 minor version ahead of the server."
+                )
+                logger.warning(
+                    f"To resolve this issue, please update your kubernetes Python client to a compatible version."
+                )
+                is_compatible = False
+                
+        return is_compatible
+    except Exception as e:
+        logger.warning(f"Failed to verify Kubernetes version compatibility: {e}")
+        return True  # Be lenient if we can't check compatibility

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/inference/hp_endpoint_base.py

@@ -14,6 +14,7 @@ from sagemaker.hyperpod.common.utils import (
     handle_exception,
     setup_logging,
     get_default_namespace,
+    verify_kubernetes_version_compatibility,
 )
 from sagemaker.hyperpod.common.telemetry.telemetry_logging import (
     _hyperpod_telemetry_emitter,
@@ -24,15 +25,18 @@ from sagemaker.hyperpod.common.telemetry.constants import Feature
 class HPEndpointBase:
     is_kubeconfig_loaded = False
 
+    @classmethod
+    def get_logger(cls):
+        return logging.getLogger(__name__)
+    
     @classmethod
     def verify_kube_config(cls):
         if not cls.is_kubeconfig_loaded:
             config.load_kube_config()
             cls.is_kubeconfig_loaded = True
-
-    @classmethod
-    def get_logger(cls):
-        return logging.getLogger(__name__)
+            
+            # Verify Kubernetes version compatibility
+            verify_kubernetes_version_compatibility(cls.get_logger())
 
     @classmethod
     def call_create_api(

sagemaker_hyperpod-3.1.0/src/sagemaker/hyperpod/inference/jumpstart_public_hub_visualization_utils.py

@@ -0,0 +1,301 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+"""Notebook visualization utilities for Models in JumpStart Public Hub."""
+from __future__ import absolute_import
+
+import time
+import boto3
+import itables
+import pandas
+import logging
+import json
+from botocore.config import Config
+from ipywidgets import Button, Output
+from IPython.display import display
+
+
+class ModelDataLoader:
+    """Handles progressive loading of model data from SageMaker Hub."""
+    
+    TIMEOUT_SECONDS = 30
+    MAX_RESULTS_PER_CALL = 100
+    
+    def __init__(self, region: str, hub_name: str = "SageMakerPublicHub"):
+        config = Config(region_name=region, retries={"max_attempts": 10, "mode": "adaptive"})
+        self.client = boto3.client("sagemaker", config=config)
+        self.hub_name = hub_name
+        self.all_data = []
+        self.next_token = None
+        self.table_output = None
+        self.load_button = None
+    
+    def load_initial_data(self, limit: int = 100):
+        """Load first batch of models and display progressive table."""
+        batch_data = self._get_batch(limit)
+        self.all_data = batch_data["data"]
+        self.next_token = batch_data["next_token"]
+        self._display_progressive_table()
+    
+    def _get_batch(self, limit: int = 100):
+        """Get a batch of model data with pagination and timeout."""
+        model_summaries = []
+        current_token = self.next_token
+        start_time = time.time()
+        
+        try:
+            while (len(model_summaries) < limit and 
+                   (time.time() - start_time) < self.TIMEOUT_SECONDS):
+                
+                params = {
+                    "HubName": self.hub_name,
+                    "HubContentType": "Model",
+                    "MaxResults": min(self.MAX_RESULTS_PER_CALL, limit - len(model_summaries))
+                }
+                if current_token:
+                    params["NextToken"] = current_token
+                
+                response = self.client.list_hub_contents(**params)
+                batch_summaries = [
+                    self._get_model_summary(summary) 
+                    for summary in response["HubContentSummaries"]
+                ]
+                model_summaries.extend(batch_summaries)
+                
+                current_token = response.get("NextToken")
+                if not current_token:
+                    break
+            
+            if (time.time() - start_time) >= self.TIMEOUT_SECONDS:
+                logging.debug(f"Retrieved {len(model_summaries)} models in {self.TIMEOUT_SECONDS} seconds. There may be more models to list, press Load More Models button to continue loading.")
+            
+            return {"data": model_summaries, "next_token": current_token}
+            
+        except Exception as e:
+            print(f"Error fetching models: {e}")
+            return {"data": model_summaries, "next_token": current_token}
+    
+    def _display_progressive_table(self):
+        """Display table with optional load more button."""
+        if not self.all_data:
+            print("No models to display")
+            return
+        
+        self._create_and_display_table()
+        self._create_load_button()
+    
+    def _create_load_button(self):
+        """Create and display load more button if needed."""
+        if self.next_token:
+            self.load_button = Button(description="Load More Models")
+            self.load_button.on_click(lambda b: self._load_more())
+            display(self.load_button)
+    
+    def _create_and_display_table(self):
+        """Create and display the data table."""
+        self.table_output = Output()
+        display(self.table_output)
+        
+        try:
+            with self.table_output:
+                self.table_output.clear_output(wait=True)
+                interactive_view(self.all_data)
+        except Exception as e:
+            print(f"Error displaying table: {e}")
+    
+    def _load_more(self):
+        """Load next batch and update consolidated table."""
+        if not self.next_token:
+            print("No more models to load")
+            return
+        
+        self._set_loading_state()
+        self._fetch_and_update_data()
+        self._update_button_state()
+    
+    def _set_loading_state(self):
+        """Set button to loading state."""
+        if self.load_button:
+            self.load_button.disabled = True
+            self.load_button.description = "Loading..."
+    
+    def _fetch_and_update_data(self):
+        """Fetch new data and update table."""
+        batch_data = self._get_batch()
+        self.next_token = batch_data["next_token"]
+        self.all_data.extend(batch_data["data"])
+        
+        with self.table_output:
+            self.table_output.clear_output(wait=True)
+            interactive_view(self.all_data)
+    
+    def _update_button_state(self):
+        """Update button state based on data availability."""
+        if not self.load_button:
+            return
+            
+        if self.next_token:
+            self.load_button.disabled = False
+            self.load_button.description = "Load More Models"
+        else:
+            self.load_button.description = "All Models Loaded"
+    
+    def _get_model_summary(self, full_summary):
+        """Extract relevant model information."""
+        keywords = full_summary["HubContentSearchKeywords"]
+        model_type = self._determine_model_type(keywords, full_summary["HubContentName"])
+        
+        return {
+            "Model Id": full_summary["HubContentName"],
+            "Model Display Name": full_summary["HubContentDisplayName"],
+            "Model Type": model_type,
+            "Model Description": full_summary["HubContentDescription"],
+            "Search Keywords": keywords,
+            "Deployment Configs": self._create_config_link(full_summary["HubContentName"]),
+        }
+    
+    def _determine_model_type(self, keywords, model_id):
+        """Determine model type from keywords or hub document."""
+        if "@model-type:proprietary" in keywords:
+            return "Proprietary"
+        elif "@model-type:open_weights" in keywords:
+            return "Open"
+        else:
+            # Check if gated via hub content document
+            hub_doc = self._get_hub_document(model_id)
+            return "Gated" if '"GatedBucket": true' in hub_doc else "Open"
+    
+    def _get_hub_document(self, model_id):
+        """Get hub content document for model."""
+        return self.client.describe_hub_content(
+            HubName=self.hub_name, 
+            HubContentType="Model", 
+            HubContentName=model_id
+        )["HubContentDocument"]
+    
+    def _get_supported_instance_types(self, model_id):
+        """Extract supported instance types from hub document."""
+        try:
+            hub_doc = self._get_hub_document(model_id)
+            doc_data = json.loads(hub_doc)
+            
+            supported_types = doc_data.get("SupportedInferenceInstanceTypes", [])
+            default_type = doc_data.get("DefaultInferenceInstanceType")
+            
+            if default_type and default_type in supported_types:
+                supported_types = [default_type] + [t for t in supported_types if t != default_type]
+            
+            return {"types": supported_types, "default": default_type, "error": None}
+        except Exception as e:
+            return {"types": [], "default": None, "error": str(e)}
+    
+    def _create_config_link(self, model_id):
+        """Create deployment config display using collapsible details for all environments."""
+        return f'<details><summary style="color: #007bff; cursor: pointer;">View SDK Config</summary><pre style="font-size: 10px; background: #f5f5f5; padding: 5px; margin: 5px 0;">{self._generate_deployment_config(model_id)}</pre></details>'
+    
+    def _generate_deployment_config(self, model_id):
+        """Generate deployment configuration code for a model."""
+        instance_data = self._get_supported_instance_types(model_id)
+        supported_types = instance_data["types"]
+        default_type = instance_data["default"]
+        error = instance_data["error"]
+
+        if error:
+            instance_type = '<ENTER-INSTANCE-TYPE>'
+            types_comment = ""
+        else:
+            instance_type = default_type if default_type else '\<ENTER-INSTANCE-TYPE\>'
+            types_comment = self._format_instance_types_comment(supported_types)
+        
+        config_code = f'''# Deployment configuration for {model_id}
+from sagemaker.hyperpod.inference.config.hp_jumpstart_endpoint_config import (
+    Model, Server, SageMakerEndpoint
+)
+from sagemaker.hyperpod.inference.hp_jumpstart_endpoint import HPJumpStartEndpoint
+
+{types_comment}
+
+# Create configs
+model = Model(
+    model_id='{model_id}',
+)
+server = Server(
+    instance_type='{instance_type}',
+)
+
+# Default endpoint name using model_id, modify as desired
+endpoint_name = SageMakerEndpoint(name='{model_id}')
+
+# Create endpoint spec
+js_endpoint = HPJumpStartEndpoint(
+    model=model,
+    server=server,
+    sage_maker_endpoint=endpoint_name,
+)
+
+# Deploy the endpoint
+js_endpoint.create()'''
+        return config_code
+    
+    def _format_instance_types_comment(self, supported_types):
+        """Format instance types comment with line breaks for better readability."""
+        if not supported_types:
+            return "# No supported instance types found"
+        
+        if len(supported_types) <= 5:
+            return f"# Supported instance types: {', '.join(supported_types)}"
+        
+        # For more than 5 instance types, format with newlines every 5 types
+        comment_lines = ["# Supported instance types:"]
+        for i in range(0, len(supported_types), 5):
+            batch = supported_types[i:i+5]
+            comment_lines.append(f"#   {', '.join(batch)}")
+        
+        return '\n'.join(comment_lines)
+
+
+def get_all_public_hub_model_data(region: str):
+    """Load and display SageMaker public hub models with progressive loading."""
+    loader = ModelDataLoader(region)
+    loader.load_initial_data()
+
+
+def interactive_view(tabular_data: list):
+    """Display interactive table in Jupyter notebook."""
+    if not tabular_data:
+        return
+    
+    _configure_itables()
+    df = pandas.DataFrame(tabular_data)
+    styled_df = _style_dataframe(df)
+    layout = _get_table_layout(len(tabular_data))
+    
+    itables.show(styled_df, layout=layout, allow_html=True)
+
+
+def _configure_itables():
+    """Configure itables for notebook display."""
+    itables.init_notebook_mode(all_interactive=True)
+    itables.options.allow_html = True
+    
+
+def _style_dataframe(df):
+    """Apply styling to dataframe."""
+    return df.style.set_properties(**{"text-align": "left"}).set_table_styles(
+        [{"selector": "th", "props": [("text-align", "left")]}]
+    )
+
+
+def _get_table_layout(data_length):
+    """Get appropriate table layout based on data size."""
+    return {} if data_length > 10 else {"topStart": None, "topEnd": "search"}

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker/hyperpod/training/hyperpod_pytorch_job.py

@@ -9,6 +9,7 @@ from sagemaker.hyperpod.common.utils import (
     handle_exception,
     get_default_namespace,
     setup_logging,
+    verify_kubernetes_version_compatibility
 )
 from sagemaker.hyperpod.common.telemetry.telemetry_logging import (
     _hyperpod_telemetry_emitter,
@@ -17,6 +18,7 @@ from sagemaker.hyperpod.common.telemetry.constants import Feature
 import yaml
 import logging
 
+
 TRAINING_GROUP = "sagemaker.amazonaws.com"
 API_VERSION = "v1"
 PLURAL = "hyperpodpytorchjobs"
@@ -36,15 +38,18 @@ class HyperPodPytorchJob(_HyperPodPytorchJob):
         default=None, description="The status of the HyperPodPytorchJob"
     )
 
+    @classmethod
+    def get_logger(cls):
+        return logging.getLogger(__name__)
+    
     @classmethod
     def verify_kube_config(cls):
         if not cls.is_kubeconfig_loaded:
             config.load_kube_config()
             cls.is_kubeconfig_loaded = True
-
-    @classmethod
-    def get_logger(cls):
-        return logging.getLogger(__name__)
+            
+            # Verify Kubernetes version compatibility
+            verify_kubernetes_version_compatibility(cls.get_logger())
 
     @_hyperpod_telemetry_emitter(Feature.HYPERPOD, "create_pytorchjob")
     def create(self, debug=False):
@@ -79,7 +84,7 @@ class HyperPodPytorchJob(_HyperPodPytorchJob):
                 plural=PLURAL,
                 body=config,
             )
-            logger.info("Successfully submitted HyperPodPytorchJob!")
+            logger.info(f"Successfully submitted HyperPodPytorchJob '{self.metadata.name}'!")
         except Exception as e:
             logger.error(f"Failed to create HyperPodPytorchJob {self.metadata.name}!")
             handle_exception(e, self.metadata.name, self.metadata.namespace)
@@ -126,7 +131,7 @@ class HyperPodPytorchJob(_HyperPodPytorchJob):
                 plural=PLURAL,
                 name=self.metadata.name,
             )
-            logger.info(f"Successful deleted HyperPodPytorchJob!")
+            logger.info(f"Successful deleted HyperPodPytorchJob '{self.metadata.name}'!")
         except Exception as e:
             logger.error(f"Failed to delete HyperPodPytorchJob {self.metadata.name}!")
             handle_exception(e, self.metadata.name, self.metadata.namespace)
@@ -230,11 +235,9 @@ class HyperPodPytorchJob(_HyperPodPytorchJob):
 
 
 def _load_hp_job(response: dict) -> HyperPodPytorchJob:
-    name = response["metadata"]["name"]
-    namespace = response["metadata"]["namespace"]
 
     spec = _HyperPodPytorchJob.model_validate(response["spec"], by_name=True)
-    metadata = Metadata(name=name, namespace=namespace)
+    metadata = Metadata(**response["metadata"])
 
     if "status" in response:
         status = HyperPodPytorchJobStatus.model_validate(

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0/src/sagemaker_hyperpod.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sagemaker-hyperpod
-Version: 3.0.2
+Version: 3.1.0
 Summary: Amazon SageMaker HyperPod SDK and CLI
 Home-page: https://github.com/aws/sagemaker-hyperpod-cli
 Author: Amazon Web Services

{sagemaker_hyperpod-3.0.2 → sagemaker_hyperpod-3.1.0}/src/sagemaker_hyperpod.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ setup.py
 src/sagemaker/__init__.py
 src/sagemaker/hyperpod/__init__.py
 src/sagemaker/hyperpod/cli/__init__.py
+src/sagemaker/hyperpod/cli/common_utils.py
 src/sagemaker/hyperpod/cli/hyp_cli.py
 src/sagemaker/hyperpod/cli/inference_utils.py
 src/sagemaker/hyperpod/cli/training_utils.py
@@ -51,6 +52,7 @@ src/sagemaker/hyperpod/inference/__init__.py
 src/sagemaker/hyperpod/inference/hp_endpoint.py
 src/sagemaker/hyperpod/inference/hp_endpoint_base.py
 src/sagemaker/hyperpod/inference/hp_jumpstart_endpoint.py
+src/sagemaker/hyperpod/inference/jumpstart_public_hub_visualization_utils.py
 src/sagemaker/hyperpod/inference/config/__init__.py
 src/sagemaker/hyperpod/inference/config/constants.py
 src/sagemaker/hyperpod/inference/config/hp_endpoint_config.py