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

sagemaker/core/apiutils/__init__.py

@@ -0,0 +1,13 @@
+# 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 providing a more pythonic style wrapper of boto."""

sagemaker/core/apiutils/_base_types.py

@@ -0,0 +1,228 @@
+# 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.
+"""Provides utilities for custom boto type objects."""
+from __future__ import absolute_import
+
+from sagemaker.core.apiutils import _boto_functions, _utils
+from sagemaker.core.common_utils import format_tags
+
+
+class ApiObject(object):
+    """A Python class representation of a boto API object.
+
+    Converts boto dicts of 'UpperCamelCase' names to dicts into/from a Python object with standard
+    python members. Clients invoke to_boto on an instance of ApiObject to transform the ApiObject
+    into a boto representation. Clients invoke from_boto on a sub-class of ApiObject to
+    instantiate an instance of that class from a boto representation.
+    """
+
+    # A map from boto 'UpperCamelCase' name to member name. If a boto name does not appear in
+    # this dict then it is converted to lower_snake_case.
+    _custom_boto_names = {}
+
+    # A map from name to an ApiObject subclass. Allows ApiObjects to contain ApiObject members.
+    _custom_boto_types = {}
+
+    def __init__(self, **kwargs):
+        """Init ApiObject."""
+        self.__dict__.update(kwargs)
+
+    @classmethod
+    def _boto_ignore(cls):
+        """Response fields to ignore by default."""
+        return ["ResponseMetadata"]
+
+    @classmethod
+    def from_boto(cls, boto_dict, **kwargs):
+        """Construct an instance of this ApiObject from a boto response.
+
+        Args:
+            boto_dict (dict): A dictionary of a boto response.
+            **kwargs: Arbitrary keyword arguments
+        """
+        if boto_dict is None:
+            return None
+
+        boto_dict = {k: v for k, v in boto_dict.items() if k not in cls._boto_ignore()}
+        custom_boto_names_to_member_names = {a: b for b, a in cls._custom_boto_names.items()}
+        cls_kwargs = _boto_functions.from_boto(
+            boto_dict, custom_boto_names_to_member_names, cls._custom_boto_types
+        )
+        cls_kwargs.update(kwargs)
+        return cls(**cls_kwargs)
+
+    @classmethod
+    def to_boto(cls, obj):
+        """Convert an object to a boto representation.
+
+        Args:
+            obj (dict): The object to convert to boto.
+        """
+        if not isinstance(obj, dict):
+            var_dict = vars(obj)
+        else:
+            var_dict = obj
+        return _boto_functions.to_boto(var_dict, cls._custom_boto_names, cls._custom_boto_types)
+
+    def __eq__(self, other):
+        """Return True if this ApiObject equals other."""
+        if isinstance(other, self.__class__):
+            return self.__dict__ == other.__dict__
+        return False
+
+    def __ne__(self, other):
+        """Return True if this ApiObject does not equal other."""
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        """Return a hashcode for this ApiObject."""
+        return hash(tuple(sorted(self.__dict__.items())))
+
+    def __repr__(self):
+        """Return a string representation of this ApiObject."""
+        return "{}({})".format(
+            type(self).__name__,
+            ",".join(["{}={}".format(k, repr(v)) for k, v in vars(self).items()]),
+        )
+
+
+class Record(ApiObject):
+    """A boto based Active Record class based on convention of CRUD operations."""
+
+    # update / delete / list method names
+    _boto_update_method = None
+    _boto_delete_method = None
+    _boto_list_method = None
+
+    # List of member names to convert to boto representations and pass to the update method.
+    _boto_update_members = []
+
+    # List of member names to convert to boto representations and pass to the delete method.
+    _boto_delete_members = []
+
+    def __init__(self, sagemaker_session=None, **kwargs):
+        """Init Record."""
+        self.sagemaker_session = sagemaker_session
+        super(Record, self).__init__(**kwargs)
+
+    @classmethod
+    def _list(
+        cls,
+        boto_list_method,
+        list_item_factory,
+        boto_list_items_name,
+        boto_next_token_name="NextToken",
+        sagemaker_session=None,
+        **kwargs,
+    ):
+        """List objects from the SageMaker API."""
+        sagemaker_session = sagemaker_session or _utils.default_session()
+        sagemaker_client = sagemaker_session.sagemaker_client
+        next_token = None
+        try:
+            while True:
+                list_request_kwargs = _boto_functions.to_boto(
+                    kwargs, cls._custom_boto_names, cls._custom_boto_types
+                )
+                if next_token:
+                    list_request_kwargs[boto_next_token_name] = next_token
+                list_method = getattr(sagemaker_client, boto_list_method)
+                list_method_response = list_method(**list_request_kwargs)
+                list_items = list_method_response.get(boto_list_items_name, [])
+                next_token = list_method_response.get(boto_next_token_name)
+                for item in list_items:
+                    yield list_item_factory(item)
+                if not next_token:
+                    break
+        except StopIteration:
+            return
+
+    @classmethod
+    def _search(
+        cls,
+        search_resource,
+        search_item_factory,
+        boto_next_token_name="NextToken",
+        sagemaker_session=None,
+        **kwargs,
+    ):
+        """Search for objects with the SageMaker API."""
+        sagemaker_session = sagemaker_session or _utils.default_session()
+        sagemaker_client = sagemaker_session.sagemaker_client
+
+        next_token = None
+        try:
+            while True:
+                search_request_kwargs = _boto_functions.to_boto(
+                    kwargs, cls._custom_boto_names, cls._custom_boto_types
+                )
+                search_request_kwargs["Resource"] = search_resource
+                if next_token:
+                    search_request_kwargs[boto_next_token_name] = next_token
+                search_method = getattr(sagemaker_client, "search")
+                search_method_response = search_method(**search_request_kwargs)
+                search_items = search_method_response.get("Results", [])
+                next_token = search_method_response.get(boto_next_token_name)
+                for item in search_items:
+                    # _TrialComponent class in experiments module is not public currently
+                    class_name = cls.__name__.lstrip("_")
+                    if class_name in item:
+                        yield search_item_factory(item[class_name])
+                if not next_token:
+                    break
+        except StopIteration:
+            return
+
+    @classmethod
+    def _construct(cls, boto_method_name, sagemaker_session=None, **kwargs):
+        """Create and invoke a SageMaker API call request."""
+        sagemaker_session = sagemaker_session or _utils.default_session()
+        instance = cls(sagemaker_session, **kwargs)
+        return instance._invoke_api(boto_method_name, kwargs)
+
+    def _set_tags(self, resource_arn=None, tags=None):
+        """Set tags on this ApiObject.
+
+        Args:
+            resource_arn (str): The arn of the Record
+            tags (Optional[Tags]): An array of Tag objects that set to Record
+
+        Returns:
+            A list of key, value pair objects. i.e. [{"key":"value"}]
+        """
+        tag_list = self.sagemaker_session.sagemaker_client.add_tags(
+            ResourceArn=resource_arn, Tags=format_tags(tags)
+        )["Tags"]
+        return tag_list
+
+    def with_boto(self, boto_dict):
+        """Update this ApiObject with a boto response.
+
+        Args:
+            boto_dict (dict): A dictionary of a boto response.
+        """
+        custom_boto_names_to_member_names = {a: b for b, a in self._custom_boto_names.items()}
+        self.__dict__.update(
+            **_boto_functions.from_boto(
+                boto_dict, custom_boto_names_to_member_names, self._custom_boto_types
+            )
+        )
+        return self
+
+    def _invoke_api(self, boto_method, boto_method_members):
+        """Invoke a SageMaker API."""
+        api_values = {k: v for k, v in vars(self).items() if k in boto_method_members}
+        api_kwargs = self.to_boto(api_values)
+        api_method = getattr(self.sagemaker_session.sagemaker_client, boto_method)
+        api_boto_response = api_method(**api_kwargs)
+        return self.with_boto(api_boto_response)

sagemaker/core/apiutils/_boto_functions.py

@@ -0,0 +1,130 @@
+# 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.
+"""Provides utilities for converting between python style and boto style."""
+from __future__ import absolute_import
+
+import re
+
+
+def to_camel_case(snake_case):
+    """Convert a snake case string to camel case.
+
+    Args:
+        snake_case (str): String to convert to camel case.
+
+    Returns:
+        str: String converted to camel case.
+    """
+    return "".join([x.title() for x in snake_case.split("_")])
+
+
+def to_pascal_case(snake_case):
+    """Convert a snake case string to PascalCase.
+
+    Args:
+        snake_case (str): String to convert to PascalCase.
+
+    Returns:
+        str: String converted to PascalCase.
+    """
+    return "".join(word.capitalize() for word in snake_case.split("_"))
+
+
+def to_snake_case(name):
+    """Convert a camel case string to snake case.
+
+    Args:
+        name (str): String to convert to snake case.
+
+    Returns:
+        str: String converted to snake case.
+    """
+    s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def from_boto(boto_dict, boto_name_to_member_name, member_name_to_type):
+    """Convert an UpperCamelCase boto response to a snake case representation.
+
+    Args:
+        boto_dict (dict[str, ?]): A boto response dictionary.
+        boto_name_to_member_name (dict[str, str]):  A map from boto name to snake_case name.
+            If a given boto name is not in the map then a default mapping is applied.
+        member_name_to_type (dict[str, (_base_types.ApiObject, boolean)]): A map from snake case
+            name to a type description tuple. The first element of the tuple, a subclass of
+            ApiObject, is the type of the mapped object. The second element indicates whether the
+            mapped element is a collection or singleton.
+
+    Returns:
+        dict: Boto response in snake case.
+    """
+    from_boto_values = {}
+    for boto_name, boto_value in boto_dict.items():
+        # Convert the boto_name to a snake-case name by preferentially looking up the boto name in
+        # boto_name_to_member_name before defaulting to the snake case representation
+        member_name = boto_name_to_member_name.get(boto_name, to_snake_case(boto_name))
+
+        # If the member name maps to a subclass of _base_types.ApiObject
+        # (i.e. it's in member_name_to_type), then transform its boto dictionary using that type:
+        if member_name in member_name_to_type:
+            api_type, is_collection = member_name_to_type[member_name]
+            if is_collection:
+                if isinstance(boto_value, dict):
+                    member_value = {
+                        key: api_type.from_boto(value) for key, value in boto_value.items()
+                    }
+                else:
+                    member_value = [api_type.from_boto(item) for item in boto_value]
+            else:
+                member_value = api_type.from_boto(boto_value)
+        # If the member name does not have a custom type definition then simply assign it the
+        # boto value.  Appropriate if the type is simple and requires not further conversion (e.g.
+        # a number or list of strings).
+        else:
+            member_value = boto_value
+        from_boto_values[member_name] = member_value
+    return from_boto_values
+
+
+def to_boto(member_vars, member_name_to_boto_name, member_name_to_type):
+    """Convert a dict of of snake case names to values into a boto UpperCamelCase representation.
+
+    Args:
+        member_vars dict[str, ?]: A map from snake case name to value.
+        member_name_to_boto_name dict[str, ?]: A map from snake_case name to boto name.
+
+     Returns:
+         dict: boto dict converted to snake case
+
+    """
+    to_boto_values = {}
+    # Strip out all entries in member_vars that have a None value. None values are treated as
+    # not having a value
+    # set, required as API operations can have optional parameters that may not take a null value.
+    member_vars = {k: v for k, v in member_vars.items() if v is not None}
+
+    # Iterate over each snake_case name and its value and map to a camel case name. If the value
+    # is an ApiObject subclass then recursively map its entries.
+    for member_name, member_value in member_vars.items():
+        boto_name = member_name_to_boto_name.get(member_name, to_camel_case(member_name))
+        api_type, is_api_collection_type = member_name_to_type.get(member_name, (None, None))
+        if is_api_collection_type and isinstance(member_value, dict):
+            boto_value = {
+                k: api_type.to_boto(v) if api_type else v for k, v in member_value.items()
+            }
+        elif is_api_collection_type and isinstance(member_value, list):
+            boto_value = [api_type.to_boto(v) if api_type else v for v in member_value]
+        else:
+            boto_value = api_type.to_boto(member_value) if api_type else member_value
+        to_boto_values[boto_name] = boto_value
+    return to_boto_values

sagemaker/core/apiutils/_utils.py

@@ -0,0 +1,34 @@
+# 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.
+"""Provides utilities for instantiating dependencies to boto-python objects."""
+from __future__ import absolute_import
+
+import random
+import time
+from sagemaker.core.helper.session_helper import Session
+
+
+def suffix():
+    """Generate a random string of length 4."""
+    alph = "abcdefghijklmnopqrstuvwxyz"
+    return "-".join([time.strftime("%Y-%m-%d-%H%M%S"), "".join(random.sample(alph, 4))])
+
+
+def name(prefix):
+    """Generate a new name with the specified prefix."""
+    return "-".join([prefix, suffix()])
+
+
+def default_session():
+    """Create a default session."""
+    return Session()

sagemaker/core/base_deserializers.py

@@ -0,0 +1,35 @@
+# 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.
+"""Backward compatibility module for base deserializers.
+
+This module provides backward compatibility for code importing from
+sagemaker.core.base_deserializers. The actual implementation is in
+sagemaker.core.deserializers.
+
+.. deprecated:: 3.0.0
+    Use :mod:`sagemaker.core.deserializers` instead.
+"""
+from __future__ import absolute_import
+
+import warnings
+
+# Re-export all deserializers from the correct location
+from sagemaker.core.deserializers import *  # noqa: F401, F403
+
+# Issue deprecation warning
+warnings.warn(
+    "Importing from sagemaker.core.base_deserializers is deprecated. "
+    "Use sagemaker.core.deserializers instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

sagemaker/core/base_serializers.py

@@ -0,0 +1,35 @@
+# 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.
+"""Backward compatibility module for base serializers.
+
+This module provides backward compatibility for code importing from
+sagemaker.core.base_serializers. The actual implementation is in
+sagemaker.core.serializers.
+
+.. deprecated:: 3.0.0
+    Use :mod:`sagemaker.core.serializers` instead.
+"""
+from __future__ import absolute_import
+
+import warnings
+
+# Re-export all serializers from the correct location
+from sagemaker.core.serializers import *  # noqa: F401, F403
+
+# Issue deprecation warning
+warnings.warn(
+    "Importing from sagemaker.core.base_serializers is deprecated. "
+    "Use sagemaker.core.serializers instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)