sagemaker-core 1.0.62__py3-none-any.whl → 2.1.1__py3-none-any.whl

sagemaker/core/user_agent.py

@@ -0,0 +1,76 @@
+# 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.
+"""Placeholder docstring"""
+from __future__ import absolute_import
+
+import json
+import os
+
+SDK_PREFIX = "AWS-SageMaker-Python-SDK"
+STUDIO_PREFIX = "AWS-SageMaker-Studio"
+NOTEBOOK_PREFIX = "AWS-SageMaker-Notebook-Instance"
+
+NOTEBOOK_METADATA_FILE = "/etc/opt/ml/sagemaker-notebook-instance-version.txt"
+STUDIO_METADATA_FILE = "/opt/ml/metadata/resource-metadata.json"
+
+SDK_VERSION ="3.0"
+
+
+def process_notebook_metadata_file():
+    """Check if the platform is SageMaker Notebook, if yes, return the InstanceType
+
+    Returns:
+        str: The InstanceType of the SageMaker Notebook if it exists, otherwise None
+    """
+    if os.path.exists(NOTEBOOK_METADATA_FILE):
+        with open(NOTEBOOK_METADATA_FILE, "r") as sagemaker_nbi_file:
+            return sagemaker_nbi_file.read().strip()
+
+    return None
+
+
+def process_studio_metadata_file():
+    """Check if the platform is SageMaker Studio, if yes, return the AppType
+
+    Returns:
+        str: The AppType of the SageMaker Studio if it exists, otherwise None
+    """
+    if os.path.exists(STUDIO_METADATA_FILE):
+        with open(STUDIO_METADATA_FILE, "r") as sagemaker_studio_file:
+            metadata = json.load(sagemaker_studio_file)
+            return metadata.get("AppType")
+
+    return None
+
+
+def get_user_agent_extra_suffix():
+    """Get the user agent extra suffix string specific to SageMaker Python SDK
+
+    Adhers to new boto recommended User-Agent 2.0 header format
+
+    Returns:
+        str: The user agent extra suffix string to be appended
+    """
+    suffix = "lib/{}#{}".format(SDK_PREFIX, SDK_VERSION)
+
+    # Get the notebook instance type and prepend it to the user agent string if exists
+    notebook_instance_type = process_notebook_metadata_file()
+    if notebook_instance_type:
+        suffix = "{} md/{}#{}".format(suffix, NOTEBOOK_PREFIX, notebook_instance_type)
+
+    # Get the studio app type and prepend it to the user agent string if exists
+    studio_app_type = process_studio_metadata_file()
+    if studio_app_type:
+        suffix = "{} md/{}#{}".format(suffix, STUDIO_PREFIX, studio_app_type)
+
+    return suffix

sagemaker/core/utilities/__init__.py

@@ -0,0 +1,24 @@
+# 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.
+"""Utilities for SageMaker Python SDK."""
+from __future__ import absolute_import
+
+from sagemaker.core.utilities.cache import LRUCache  # noqa: F401
+from sagemaker.core.utilities.search_expression import (  # noqa: F401
+    BooleanOperator,
+    Filter,
+    NestedFilter,
+    Operator,
+    SearchExpression,
+    SearchObject,
+)

sagemaker/core/utilities/cache.py

@@ -0,0 +1,169 @@
+# 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.
+"""This module defines a LRU cache class."""
+from __future__ import absolute_import
+
+import datetime
+import collections
+from typing import Tuple, TypeVar, Generic, Callable, Optional
+
+KeyType = TypeVar("KeyType")
+ValType = TypeVar("ValType")
+
+
+class LRUCache(Generic[KeyType, ValType]):
+    """Class that implements LRU cache with expiring items.
+
+    LRU caches remove items in a FIFO manner, such that the oldest
+    items to be used are the first to be removed.
+    If you attempt to retrieve a cache item that is older than the
+    expiration time, the item will be invalidated.
+    """
+
+    class Element:
+        """Class describes the values in the cache.
+
+        This object stores the value itself as well as a timestamp so that this
+        element can be invalidated if it becomes too old.
+        """
+
+        def __init__(self, value: ValType, creation_time: datetime.datetime):
+            """Initialize an ``Element`` instance for ``LRUCache``.
+
+            Args:
+                value (ValType): Value that is stored in cache.
+                creation_time (datetime.datetime): Time at which cache item was created.
+            """
+            self.value = value
+            self.creation_time = creation_time
+
+    def __init__(
+        self,
+        max_cache_items: int,
+        expiration_horizon: datetime.timedelta,
+        retrieval_function: Callable[[KeyType, ValType], ValType],
+    ) -> None:
+        """Initialize an ``LRUCache`` instance.
+
+        Args:
+            max_cache_items (int): Maximum number of items to store in cache.
+            expiration_horizon (datetime.timedelta): Maximum time duration a cache element can
+                persist before being invalidated.
+            retrieval_function (Callable[[KeyType, ValType], ValType]): Function which maps cache
+                keys and current values to new values. This function must have kwarg arguments
+                ``key`` and ``value``. This function is called as a fallback when the key
+                is not found in the cache, or a key has expired.
+
+        """
+        self._max_cache_items = max_cache_items
+        self._lru_cache: collections.OrderedDict = collections.OrderedDict()
+        self._expiration_horizon = expiration_horizon
+        self._retrieval_function = retrieval_function
+
+    def __len__(self) -> int:
+        """Returns number of elements in cache."""
+        return len(self._lru_cache)
+
+    def __contains__(self, key: KeyType) -> bool:
+        """Returns True if key is found in cache, False otherwise.
+
+        Args:
+            key (KeyType): Key in cache to retrieve.
+        """
+        return key in self._lru_cache
+
+    def clear(self) -> None:
+        """Deletes all elements from the cache."""
+        self._lru_cache.clear()
+
+    def get(
+        self, key: KeyType, data_source_fallback: Optional[bool] = True
+    ) -> Tuple[ValType, bool]:
+        """Returns value corresponding to key in cache and boolean indicating cache hit.
+
+        Args:
+            key (KeyType): Key in cache to retrieve.
+            data_source_fallback (Optional[bool]): True if data should be retrieved if
+                it's stale or not in cache. Default: True.
+
+        Raises:
+            KeyError: If key is not found in cache or is outdated and
+            ``data_source_fallback`` is False.
+        """
+        if data_source_fallback:
+            if key in self._lru_cache:
+                return self._get_item(key, False), True
+            self.put(key)
+            return self._get_item(key, False), False
+        return self._get_item(key, True), True
+
+    def put(self, key: KeyType, value: Optional[ValType] = None) -> None:
+        """Adds key to cache using ``retrieval_function``.
+
+        If value is provided, this is used instead. If the key is already in cache,
+        the old element is removed. If the cache size exceeds the size limit, old
+        elements are removed in order to meet the limit.
+
+        Args:
+            key (KeyType): Key in cache to retrieve.
+            value (Optional[ValType]): Value to store for key. Default: None.
+        """
+        curr_value = None
+        if key in self._lru_cache:
+            curr_value = self._lru_cache.pop(key)
+
+        while len(self._lru_cache) >= self._max_cache_items:
+            self._lru_cache.popitem(last=False)
+
+        if value is None:
+            value = self._retrieval_function(  # type: ignore
+                key=key, value=curr_value.element if curr_value else None
+            )
+
+        self._lru_cache[key] = self.Element(
+            value=value, creation_time=datetime.datetime.now(tz=datetime.timezone.utc)
+        )
+
+    def _get_item(self, key: KeyType, fail_on_old_value: bool) -> ValType:
+        """Returns value from cache corresponding to key.
+
+        If ``fail_on_old_value``, a KeyError is raised instead of a new value
+            getting fetched.
+
+        Args:
+            key (KeyType): Key in cache to retrieve.
+            fail_on_old_value (bool): True if a KeyError is raised when the cache value
+                is old.
+
+        Raises:
+            KeyError: If key is not in cache or if key is old in cache
+                and fail_on_old_value is True.
+        """
+        try:
+            element = self._lru_cache.pop(key)
+            curr_time = datetime.datetime.now(tz=datetime.timezone.utc)
+            element_age = curr_time - element.creation_time
+            if element_age > self._expiration_horizon:
+                if fail_on_old_value:
+                    raise KeyError(
+                        f"{key} has aged beyond allowed time {self._expiration_horizon}. "
+                        f"Element created at {element.creation_time}."
+                    )
+                element.value = self._retrieval_function(  # type: ignore
+                    key=key, value=element.value
+                )
+                element.creation_time = curr_time
+            self._lru_cache[key] = element
+            return element.value
+        except KeyError:
+            raise KeyError(f"{key} not found in LRUCache!")

sagemaker/core/utilities/search_expression.py

@@ -0,0 +1,133 @@
+# 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.
+"""Simplify Search Expression by provide a simplified DSL"""
+from __future__ import absolute_import
+
+from enum import Enum, unique
+
+from sagemaker.core.apiutils._base_types import ApiObject
+
+
+# TODO: we should update the lineage to use search expressions
+# defined here in a separate change
+@unique
+class Operator(Enum):
+    """Search operators"""
+
+    EQUALS = "Equals"
+    NOT_EQUALS = "NotEquals"
+    GREATER_THAN = "GreaterThan"
+    GREATER_THAN_OR_EQUAL = "GreaterThanOrEqualTo"
+    LESS_THAN = "LessThan"
+    LESS_THAN_OR_EQUAL = "LessThanOrEqualTo"
+    CONTAINS = "Contains"
+    EXISTS = "Exists"
+    NOT_EXISTS = "NotExists"
+
+
+@unique
+class BooleanOperator(Enum):
+    """Boolean search operation enum"""
+
+    AND = "And"
+    OR = "Or"
+
+
+class SearchObject(ApiObject):
+    """Search Object"""
+
+    def to_boto(self):
+        """Convert a search object to boto"""
+        return ApiObject.to_boto(self)
+
+
+class Filter(SearchObject):
+    """A Python class represent a Search Filter object."""
+
+    name = None
+    operator = None
+    value = None
+
+    def __init__(self, name, operator=None, value=None, **kwargs):
+        """Construct a Filter object
+
+        Args:
+            name (str): filter field name
+            operator (Operator): one of Operator enum
+            value (str): value of the field
+        """
+        super().__init__(**kwargs)
+        self.name = name
+        self.operator = None if operator is None else operator.value
+        self.value = value
+
+
+class NestedFilter(SearchObject):
+    """A Python class represent a Nested Filter object."""
+
+    nested_property_name = None
+    filters = None
+
+    def __init__(self, property_name, filters, **kwargs):
+        """Construct a Nested Filter object
+
+        Args:
+            property_name (str): nested property name
+            filters (List[Filter]): list of Filter objects
+        """
+        super().__init__(**kwargs)
+        self.nested_property_name = property_name
+        self.filters = list(map(lambda x: x.to_boto(), filters))
+
+
+class SearchExpression(SearchObject):
+    """A Python class representation of a Search Expression object.
+
+    A sample search expression defined in here:
+    https://boto3.amazonaws.com/v1/documentation/api/1.12.8/reference/services/sagemaker.html#SageMaker.Client.search
+    """
+
+    filters = None
+    nested_filters = None
+    operator = None
+    sub_expressions = None
+
+    def __init__(
+        self,
+        filters=None,
+        nested_filters=None,
+        sub_expressions=None,
+        boolean_operator=BooleanOperator.AND,
+        **kwargs,
+    ):
+        """Construct a Search Expression object
+
+        Args:
+            filters (List[Filter]): list of Filter objects
+            nested_filters (List[NestedFilter]): list of Nested Filters objects
+            sub_expressions (List[SearchExpression]): list of Search Expression objects
+            boolean_operator (BooleanOperator): one of the boolean operator enums
+        """
+        super().__init__(**kwargs)
+        if filters is None and nested_filters is None and sub_expressions is None:
+            raise ValueError(
+                "You must specify at least one subexpression, filter, or nested filter"
+            )
+        self.filters = None if filters is None else list(map(lambda x: x.to_boto(), filters))
+        self.nested_filters = (
+            None if nested_filters is None else list(map(lambda x: x.to_boto(), nested_filters))
+        )
+        self.sub_expressions = (
+            None if sub_expressions is None else list(map(lambda x: x.to_boto(), sub_expressions))
+        )
+        self.operator = boolean_operator.value

sagemaker/core/utils/__init__.py

@@ -0,0 +1,48 @@
+# 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.
+"""Utilities package for SageMaker Core.
+
+This package re-exports commonly used utility functions from common_utils
+for backward compatibility and convenience.
+
+Note: Uses lazy imports via __getattr__ to avoid circular import issues.
+"""
+from __future__ import absolute_import
+
+__all__ = [
+    "_save_model",
+    "download_file_from_url",
+    "custom_extractall_tarfile",
+    "download_file",
+    "download_folder",
+    "create_tar_file",
+    "repack_model",
+    "name_from_image",
+    "name_from_base",
+    "unique_name_from_base",
+    "unique_name_from_base_uuid4",
+    "base_name_from_image",
+    "base_from_name",
+    "sagemaker_timestamp",
+    "sagemaker_short_timestamp",
+    "get_config_value",
+]
+
+
+def __getattr__(name):
+    """Lazy import to avoid circular dependencies."""
+    if name in __all__:
+        from sagemaker.core import common_utils
+
+        return getattr(common_utils, name)
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

{sagemaker_core/main → sagemaker/core/utils}/code_injection/codec.py

@@ -15,8 +15,8 @@ import logging
 from dataclasses import asdict
 import re
 
-from sagemaker_core.main.code_injection.shape_dag import SHAPE_DAG
-from sagemaker_core.main.code_injection.constants import (
+from sagemaker.core.utils.code_injection.shape_dag import SHAPE_DAG
+from sagemaker.core.utils.code_injection.constants import (
     BASIC_TYPES,
     STRUCTURE_TYPE,
     LIST_TYPE,