feat: Bedrock Store and Marketplace model support in HubService

Feat: Bedrock Store and Marketplace model support in HubService

fix: Adding test for tags

fix: Adding more fields

fix: Fixing tag generation

feat: Adding BRS and marketplace model support

fix: Adding better flag

fix: Making fields non-required

fix: Adding more parsing logic

fix: Renaming

fix: Adding test

fix: reverting comment

fix: Adding tests

fix: Adding initial prop support logic

fix: Adding initial prop management

fix: Adding new stuff

fix: linting

fix: trigger github acitons

fix: revertin

Author: chrstfu

src/sagemaker/jumpstart/enums.py

@@ -82,6 +82,12 @@ class VariableTypes(str, Enum):
     BOOL = "bool"
 
 
+class HubContentCapability(str, Enum):
+    """Enum class for HubContent capabilities."""
+
+    BEDROCK_CONSOLE = "BEDROCK_CONSOLE"
+
+
 class JumpStartTag(str, Enum):
     """Enum class for tag keys to apply to JumpStart models."""
 
@@ -99,6 +105,8 @@ class JumpStartTag(str, Enum):
 
     HUB_CONTENT_ARN = "sagemaker-sdk:hub-content-arn"
 
+    BEDROCK = "sagemaker-sdk:bedrock"
+
 
 class SerializerType(str, Enum):
     """Enum class for serializers associated with JumpStart models."""

src/sagemaker/jumpstart/factory/model.py

@@ -41,7 +41,7 @@
 from sagemaker.model_metrics import ModelMetrics
 from sagemaker.metadata_properties import MetadataProperties
 from sagemaker.drift_check_baselines import DriftCheckBaselines
-from sagemaker.jumpstart.enums import JumpStartScriptScope, JumpStartModelType
+from sagemaker.jumpstart.enums import JumpStartScriptScope, JumpStartModelType, HubContentCapability
 from sagemaker.jumpstart.types import (
     HubContentType,
     JumpStartModelDeployKwargs,
@@ -51,7 +51,9 @@
 )
 from sagemaker.jumpstart.utils import (
     add_hub_content_arn_tags,
+    add_bedrock_store_tags,
     add_jumpstart_model_info_tags,
+    add_bedrock_store_tags,
     get_default_jumpstart_session_with_user_agent_suffix,
     get_neo_content_bucket,
     get_top_ranked_config_name,
@@ -488,6 +490,10 @@ def _add_tags_to_kwargs(kwargs: JumpStartModelDeployKwargs) -> Dict[str, Any]:
             )
         kwargs.tags = add_hub_content_arn_tags(kwargs.tags, hub_content_arn=hub_content_arn)
 
+    if hasattr(kwargs.specs, "capabilities") and kwargs.specs.capabilities is not None:
+        if HubContentCapability.BEDROCK_CONSOLE in kwargs.specs.capabilities:
+            kwargs.tags = add_bedrock_store_tags(kwargs.tags, compatibility="compatible")
+
     return kwargs
 
 

src/sagemaker/jumpstart/hub/interfaces.py

@@ -451,12 +451,14 @@ def from_json(self, json_obj: str) -> None:
 class HubModelDocument(HubDataHolderType):
     """Data class for model type HubContentDocument from session.describe_hub_content()."""
 
-    SCHEMA_VERSION = "2.2.0"
+    SCHEMA_VERSION = "2.3.0"
 
     __slots__ = [
         "url",
         "min_sdk_version",
         "training_supported",
+        "model_types",
+        "capabilities",
         "incremental_training_supported",
         "dynamic_container_deployment_supported",
         "hosting_ecr_uri",
@@ -469,6 +471,7 @@ class HubModelDocument(HubDataHolderType):
         "hosting_use_script_uri",
         "hosting_eula_uri",
         "hosting_model_package_arn",
+        "model_subscription_link",
         "inference_configs",
         "inference_config_components",
         "inference_config_rankings",
@@ -549,18 +552,22 @@ def from_json(self, json_obj: Dict[str, Any]) -> None:
         Args:
             json_obj (Dict[str, Any]): Dictionary representation of hub model document.
         """
-        self.url: str = json_obj["Url"]
-        self.min_sdk_version: str = json_obj["MinSdkVersion"]
-        self.hosting_ecr_uri: Optional[str] = json_obj["HostingEcrUri"]
-        self.hosting_artifact_uri = json_obj["HostingArtifactUri"]
-        self.hosting_script_uri = json_obj["HostingScriptUri"]
-        self.inference_dependencies: List[str] = json_obj["InferenceDependencies"]
+        self.url: str = json_obj.get("Url")
+        self.min_sdk_version: str = json_obj.get("MinSdkVersion")
+        self.hosting_ecr_uri: Optional[str] = json_obj.get("HostingEcrUri")
+        self.hosting_artifact_uri = json_obj.get("HostingArtifactUri")
+        self.hosting_script_uri = json_obj.get("HostingScriptUri")
+        self.inference_dependencies: List[str] = json_obj.get("InferenceDependencies")
         self.inference_environment_variables: List[JumpStartEnvironmentVariable] = [
             JumpStartEnvironmentVariable(env_variable, is_hub_content=True)
-            for env_variable in json_obj["InferenceEnvironmentVariables"]
+            for env_variable in json_obj.get("InferenceEnvironmentVariables", [])
         ]
-        self.training_supported: bool = bool(json_obj["TrainingSupported"])
-        self.incremental_training_supported: bool = bool(json_obj["IncrementalTrainingSupported"])
+        self.model_types: Optional[List[str]] = json_obj.get("ModelTypes")
+        self.capabilities: Optional[List[str]] = json_obj.get("Capabilities")
+        self.training_supported: bool = bool(json_obj.get("TrainingSupported"))
+        self.incremental_training_supported: bool = bool(
+            json_obj.get("IncrementalTrainingSupported")
+        )
         self.dynamic_container_deployment_supported: Optional[bool] = (
             bool(json_obj.get("DynamicContainerDeploymentSupported"))
             if json_obj.get("DynamicContainerDeploymentSupported")
@@ -586,6 +593,8 @@ def from_json(self, json_obj: Dict[str, Any]) -> None:
         self.hosting_eula_uri: Optional[str] = json_obj.get("HostingEulaUri")
         self.hosting_model_package_arn: Optional[str] = json_obj.get("HostingModelPackageArn")
 
+        self.model_subscription_link: Optional[str] = json_obj.get("ModelSubscriptionLink")
+
         self.inference_config_rankings = self._get_config_rankings(json_obj)
         self.inference_config_components = self._get_config_components(json_obj)
         self.inference_configs = self._get_configs(json_obj)

src/sagemaker/jumpstart/hub/parser_utils.py

@@ -18,13 +18,9 @@
 from typing import Any, Dict, List, Optional
 
 
-def camel_to_snake(camel_case_string: str) -> str:
-    """Converts camelCaseString or UpperCamelCaseString to snake_case_string."""
-    snake_case_string = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", camel_case_string)
-    if "-" in snake_case_string:
-        # remove any hyphen from the string for accurate conversion.
-        snake_case_string = snake_case_string.replace("-", "")
-    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", snake_case_string).lower()
+def pascal_to_snake(camel_case_string: str) -> str:
+    """Converts PascalCase to snake_case_string."""
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", camel_case_string).lower()
 
 
 def snake_to_upper_camel(snake_case_string: str) -> str:

src/sagemaker/jumpstart/hub/parsers.py

@@ -27,7 +27,7 @@
     HubModelDocument,
 )
 from sagemaker.jumpstart.hub.parser_utils import (
-    camel_to_snake,
+    pascal_to_snake,
     snake_to_upper_camel,
     walk_and_apply_json,
 )
@@ -86,7 +86,7 @@ def get_model_spec_arg_keys(
         arg_keys = []
 
     if naming_convention == NamingConventionType.SNAKE_CASE:
-        arg_keys = [camel_to_snake(key) for key in arg_keys]
+        arg_keys = [pascal_to_snake(key) for key in arg_keys]
     elif naming_convention == NamingConventionType.UPPER_CAMEL_CASE:
         return arg_keys
     else:
@@ -137,6 +137,8 @@ def make_model_specs_from_describe_hub_content_response(
     hub_model_document: HubModelDocument = response.hub_content_document
     specs["url"] = hub_model_document.url
     specs["min_sdk_version"] = hub_model_document.min_sdk_version
+    specs["model_types"] = hub_model_document.model_types
+    specs["capabilities"] = hub_model_document.capabilities
     specs["training_supported"] = bool(hub_model_document.training_supported)
     specs["incremental_training_supported"] = bool(
         hub_model_document.incremental_training_supported
@@ -146,15 +148,19 @@ def make_model_specs_from_describe_hub_content_response(
     specs["inference_config_components"] = hub_model_document.inference_config_components
     specs["inference_config_rankings"] = hub_model_document.inference_config_rankings
 
-    hosting_artifact_bucket, hosting_artifact_key = parse_s3_url(  # pylint: disable=unused-variable
-        hub_model_document.hosting_artifact_uri
-    )
-    specs["hosting_artifact_key"] = hosting_artifact_key
-    specs["hosting_artifact_uri"] = hub_model_document.hosting_artifact_uri
-    hosting_script_bucket, hosting_script_key = parse_s3_url(  # pylint: disable=unused-variable
-        hub_model_document.hosting_script_uri
-    )
-    specs["hosting_script_key"] = hosting_script_key
+    if hub_model_document.hosting_artifact_uri:
+        _, hosting_artifact_key = parse_s3_url(  # pylint: disable=unused-variable
+            hub_model_document.hosting_artifact_uri
+        )
+        specs["hosting_artifact_key"] = hosting_artifact_key
+        specs["hosting_artifact_uri"] = hub_model_document.hosting_artifact_uri
+
+    if hub_model_document.hosting_script_uri:
+        _, hosting_script_key = parse_s3_url(  # pylint: disable=unused-variable
+            hub_model_document.hosting_script_uri
+        )
+        specs["hosting_script_key"] = hosting_script_key
+
     specs["inference_environment_variables"] = hub_model_document.inference_environment_variables
     specs["inference_vulnerable"] = False
     specs["inference_dependencies"] = hub_model_document.inference_dependencies
@@ -201,7 +207,7 @@ def make_model_specs_from_describe_hub_content_response(
     default_payloads: Dict[str, Any] = {}
     if hub_model_document.default_payloads is not None:
         for alias, payload in hub_model_document.default_payloads.items():
-            default_payloads[alias] = walk_and_apply_json(payload.to_json(), camel_to_snake)
+            default_payloads[alias] = walk_and_apply_json(payload.to_json(), pascal_to_snake)
         specs["default_payloads"] = default_payloads
     specs["gated_bucket"] = hub_model_document.gated_bucket
     specs["inference_volume_size"] = hub_model_document.inference_volume_size
@@ -219,6 +225,10 @@ def make_model_specs_from_describe_hub_content_response(
 
     if hub_model_document.hosting_model_package_arn:
         specs["hosting_model_package_arns"] = {region: hub_model_document.hosting_model_package_arn}
+    
+    specs["model_subscription_link"] = hub_model_document.model_subscription_link
+
+    specs["model_subscription_link"] = hub_model_document.model_subscription_link
 
     specs["hosting_use_script_uri"] = hub_model_document.hosting_use_script_uri
 

src/sagemaker/jumpstart/hub/utils.py

@@ -14,7 +14,7 @@
 """This module contains utilities related to SageMaker JumpStart Hub."""
 from __future__ import absolute_import
 import re
-from typing import Optional
+from typing import Optional, List, Any
 from sagemaker.jumpstart.hub.types import S3ObjectLocation
 from sagemaker.s3_utils import parse_s3_url
 from sagemaker.session import Session
@@ -23,6 +23,8 @@
 from sagemaker.jumpstart import constants
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 
+PROPRIETARY_VERSION_KEYWORD = "@marketplace-version:"
+
 
 def get_info_from_hub_resource_arn(
     arn: str,
@@ -117,8 +119,8 @@ def generate_hub_arn_for_init_kwargs(
 
     hub_arn = None
     if hub_name:
-        if hub_name == constants.JUMPSTART_MODEL_HUB_NAME:
-            return None
+        # if hub_name == constants.JUMPSTART_MODEL_HUB_NAME:
+        #     return None
         match = re.match(constants.HUB_ARN_REGEX, hub_name)
         if match:
             hub_arn = hub_name
@@ -207,6 +209,24 @@ def get_hub_model_version(
     except Exception as ex:
         raise Exception(f"Failed calling list_hub_content_versions: {str(ex)}")
 
+    open_weight_hub_content_version = _get_open_weight_hub_model_version(
+        hub_content_summaries, hub_model_version
+    )
+    if open_weight_hub_content_version:
+        return open_weight_hub_content_version
+
+    proprietary_hub_content_version = _get_proprietary_hub_model_version(
+        hub_content_summaries, hub_model_version
+    )
+    if proprietary_hub_content_version:
+        return proprietary_hub_content_version
+
+    raise KeyError(f"Could not find HubContent with specified version: {hub_model_version}")
+
+
+def _get_open_weight_hub_model_version(
+    hub_content_summaries: List[Any], hub_model_version: Optional[str] = None
+) -> Optional[str]:
     available_model_versions = [model.get("HubContentVersion") for model in hub_content_summaries]
 
     if hub_model_version == "*" or hub_model_version is None:
@@ -215,10 +235,41 @@ def get_hub_model_version(
     try:
         spec = SpecifierSet(f"=={hub_model_version}")
     except InvalidSpecifier:
-        raise KeyError(f"Bad semantic version: {hub_model_version}")
+        return None
     available_versions_filtered = list(spec.filter(available_model_versions))
     if not available_versions_filtered:
-        raise KeyError("Model version not available in the Hub")
+        return None
     hub_model_version = str(max(available_versions_filtered))
 
     return hub_model_version
+
+
+def _get_proprietary_hub_model_version(
+    hub_content_summaries: List[Any], proprietary_hub_model_version: str
+) -> Optional[str]:
+
+    for model in hub_content_summaries:
+        model_search_keywords = model.get("HubContentSearchKeywords", [])
+        if _hub_search_keywords_contains_proprietary_version(
+            model_search_keywords, proprietary_hub_model_version
+        ):
+            return model.get("HubContentVersion")
+
+    return None
+
+
+def _hub_search_keywords_contains_proprietary_version(
+    model_search_keywords: List[str], proprietary_hub_model_version: str
+) -> bool:
+    proprietary_version_keyword = next(
+        filter(lambda s: s.startswith(PROPRIETARY_VERSION_KEYWORD), model_search_keywords), None
+    )
+
+    if not proprietary_version_keyword:
+        return False
+
+    proprietary_version = proprietary_version_keyword.lstrip(PROPRIETARY_VERSION_KEYWORD)
+    if proprietary_version == proprietary_hub_model_version:
+        return True
+
+    return False