feat: hub search and metadata, trainer job handles, typed deploy options, endpoint diagnostics, Bedrock and S3 helpers

docs/model_customization/model_customization.rst

@@ -154,14 +154,15 @@ Key Features
 
     # Re-attach (HyperPod — needs cluster name for log group resolution)
     from sagemaker.train import SFTTrainer
+    from sagemaker.core.resources import TrainingJob
     from sagemaker.core.training.configs import HyperPodCompute
 
     trainer = SFTTrainer(
         model="nova-textgeneration-micro",
         training_dataset="s3://unused",
         compute=HyperPodCompute(cluster_name="my-cluster", instance_type="ml.p5.48xlarge")
     )
-    trainer._latest_training_job = "my-hp-job"
+    trainer.latest_training_job = TrainingJob.get("my-hp-job")
     df = trainer.show_metrics()
 
 **Monitoring: stream_logs()**

docs/training/index.rst

@@ -299,13 +299,35 @@ Train pre-configured models from the SageMaker JumpStart hub using ``ModelTraine
    # Complex queries with filters
    text_gen = search_public_hub_models(query="@task:text-generation")
 
+**Reading a Hub Model's Metadata:**
+
+.. code-block:: python
+
+   from sagemaker.core.resources import HubContent
+
+   # Every model of the public hub, with the fields the hub tags it with
+   small_sft_models = [
+       content.hub_content_name
+       for content in HubContent.get_all(hub_name="SageMakerPublicHub", hub_content_type="Model")
+       if content.supports_technique("sft") and content.model_size in ("<1b", "1b-10b")
+   ]
+
+   # One model; the document fills in fields the 50-keyword cap dropped
+   content = HubContent.get(
+       hub_name="SageMakerPublicHub",
+       hub_content_type="Model",
+       hub_content_name="meta-textgeneration-llama-3-2-1b",
+   )
+   print(content.license, content.provider, content.tasks, content.fine_tuning_techniques())
+
 Key points:
 
 - ``from_jumpstart_config()`` auto-configures training image, instance type, and default hyperparameters
 - Override any default hyperparameters while keeping proven defaults for the rest
 - JumpStart provides built-in datasets so you can start training immediately
 - Supports HuggingFace, XGBoost, CatBoost, LightGBM, and many more frameworks
 - Use ``list_jumpstart_models()`` and ``search_public_hub_models()`` to discover available models
+- ``HubContent`` exposes ``tasks``, ``license``, ``provider``, ``model_size``, ``context_window``, ``languages``, ``capabilities``, and ``recipes`` read from its search keywords and document, so no caller parses ``HubContentSearchKeywords`` by hand
 
 :doc:`Full example notebook <../v3-examples/training-examples/jumpstart-training-example>`
 
@@ -434,7 +456,7 @@ Provide an ordered list of candidate instance types and the platform launches th
 
 .. code-block:: python
 
-   training_job = model_trainer._latest_training_job
+   training_job = model_trainer.latest_training_job
    training_job.refresh()
 
    resource_config = training_job.resource_config

sagemaker-core/src/sagemaker/core/common_utils.py

@@ -1688,12 +1688,53 @@ def create_paginator_config(max_items: int = None, page_size: int = None) -> Dic
     }
 
 
+def _normalize_tag(tag: Any) -> TagsDict:
+    """Return one tag as a boto-style ``{"Key": ..., "Value": ...}`` dict.
+
+    Accepts the boto form, the ``{"key": ..., "value": ...}`` form that the
+    ``sagemaker.core.resources`` classes take, and a ``Tag`` shape object (anything
+    with ``key`` and ``value`` attributes). Any other input raises ``TypeError`` so a
+    malformed tag fails at the call site instead of as a ``KeyError`` deep in a
+    deploy path.
+    """
+    if isinstance(tag, dict):
+        if "Key" in tag:
+            return {"Key": tag["Key"], "Value": tag.get("Value")}
+        if "key" in tag:
+            return {"Key": tag["key"], "Value": tag.get("value")}
+        raise TypeError(
+            "A tag dict must have a 'Key' (or 'key') entry, "
+            f"got {sorted(tag)}. Pass a {{key: value}} mapping to set many tags at once."
+        )
+    if hasattr(tag, "key") and hasattr(tag, "value"):
+        return {"Key": tag.key, "Value": tag.value}
+    raise TypeError(
+        "A tag must be a {'Key': ..., 'Value': ...} dict, a {'key': ..., 'value': ...} dict, "
+        f"or a Tag object, got {type(tag).__name__}."
+    )
+
+
 def format_tags(tags: Tags) -> List[TagsDict]:
-    """Process tags to turn them into the expected format for Sagemaker."""
+    """Process tags to turn them into the expected format for Sagemaker.
+
+    Every accepted representation comes out as a list of boto-style
+    ``{"Key": ..., "Value": ...}`` dicts:
+
+    * a ``{key: value}`` mapping, one tag per entry;
+    * a single tag dict or ``Tag`` object;
+    * a list of tag dicts in either casing, ``Tag`` objects, or a mix.
+
+    ``None`` is returned unchanged.
+    """
+    if tags is None:
+        return tags
     if isinstance(tags, dict):
+        if "Key" in tags or "key" in tags:
+            return [_normalize_tag(tags)]
         return [{"Key": str(k), "Value": str(v)} for k, v in tags.items()]
-
-    return tags
+    if isinstance(tags, (list, tuple)):
+        return [_normalize_tag(tag) for tag in tags]
+    return [_normalize_tag(tags)]
 
 
 def _get_resolved_path(path):
@@ -2124,8 +2165,9 @@ def tag_exists(tag: TagsDict, curr_tags: Optional[Tags]) -> bool:
     if curr_tags is None:
         return False
 
-    for curr_tag in curr_tags:
-        if tag["Key"] == curr_tag["Key"]:
+    key = _normalize_tag(tag)["Key"]
+    for curr_tag in format_tags(curr_tags):
+        if key == curr_tag["Key"]:
             return True
 
     return False
@@ -2141,21 +2183,18 @@ def _validate_new_tags(new_tags: Optional[Tags], curr_tags: Optional[Tags]) -> O
     Returns:
         Optional[Tags]: The updated tags.
     """
-    if curr_tags is None:
-        return new_tags
+    if new_tags is None:
+        return format_tags(curr_tags) if curr_tags is not None else None
 
-    if curr_tags and isinstance(curr_tags, dict):
-        curr_tags = [curr_tags]
+    if curr_tags is None:
+        return format_tags(new_tags)
 
-    if isinstance(new_tags, dict):
-        if not tag_exists(new_tags, curr_tags):
-            curr_tags.append(new_tags)
-    elif isinstance(new_tags, list):
-        for new_tag in new_tags:
-            if not tag_exists(new_tag, curr_tags):
-                curr_tags.append(new_tag)
+    merged = format_tags(curr_tags)
+    for new_tag in format_tags(new_tags):
+        if not tag_exists(new_tag, merged):
+            merged.append(new_tag)
 
-    return curr_tags
+    return merged
 
 
 def remove_tag_with_key(key: str, tags: Optional[Tags]) -> Optional[Tags]:
@@ -2170,11 +2209,9 @@ def remove_tag_with_key(key: str, tags: Optional[Tags]) -> Optional[Tags]:
     """
     if tags is None:
         return tags
-    if isinstance(tags, dict):
-        tags = [tags]
 
     updated_tags = []
-    for tag in tags:
+    for tag in format_tags(tags):
         if tag["Key"] != key:
             updated_tags.append(tag)