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

sagemaker/core/remote_function/custom_file_filter.py

@@ -0,0 +1,128 @@
+# 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.
+"""SageMaker remote function client."""
+from __future__ import absolute_import
+
+import fnmatch
+import os
+import shutil
+from typing import List, Optional, Callable, Union
+
+from sagemaker.core.common_utils import resolve_value_from_config
+from sagemaker.core.config.config_schema import REMOTE_FUNCTION_PATH, CUSTOM_FILE_FILTER
+
+
+class CustomFileFilter:
+    """Configuration that specifies how the local working directory should be packaged."""
+
+    def __init__(self, *, ignore_name_patterns: List[str] = None):
+        """Initialize a CustomFileFilter.
+
+        Args:
+            ignore_name_patterns (List[str]): ignore files or directories with names
+              that match one of the glob-style patterns. Defaults to None.
+        """
+
+        if ignore_name_patterns is None:
+            ignore_name_patterns = []
+
+        self._workdir = os.getcwd()
+        self._ignore_name_patterns = ignore_name_patterns
+
+    @property
+    def ignore_name_patterns(self):
+        """Get the ignore name patterns."""
+        return self._ignore_name_patterns
+
+    @property
+    def workdir(self):
+        """Get the working directory."""
+        return self._workdir
+
+
+def resolve_custom_file_filter_from_config_file(
+    direct_input: Union[Callable[[str, List], List], CustomFileFilter] = None,
+    sagemaker_session=None,
+) -> Union[Callable[[str, List], List], CustomFileFilter, None]:
+    """Resolve the CustomFileFilter configuration from the config file.
+
+    Args:
+        direct_input (Callable[[str, List], List], CustomFileFilter): direct input from the user.
+        sagemaker_session (sagemaker.core.helper.session.Session): sagemaker session.
+    Returns:
+        CustomFileFilter: configuration that specifies how the local
+            working directory should be packaged.
+    """
+    if direct_input is not None:
+        return direct_input
+    ignore_name_patterns = resolve_value_from_config(
+        direct_input=None,
+        config_path=".".join([REMOTE_FUNCTION_PATH, CUSTOM_FILE_FILTER, "IgnoreNamePatterns"]),
+        default_value=None,
+        sagemaker_session=sagemaker_session,
+    )
+    if ignore_name_patterns is not None:
+        return CustomFileFilter(ignore_name_patterns=ignore_name_patterns)
+    return None
+
+
+def copy_workdir(
+    dst: str,
+    custom_file_filter: Optional[Union[Callable[[str, List], List], CustomFileFilter]] = None,
+):
+    """Copy the local working directory to the destination.
+
+    Args:
+        dst (str): destination path.
+        custom_file_filter (Union[Callable[[str, List], List], CustomFileFilter): configuration that
+            specifies how the local working directory should be packaged.
+    """
+
+    def _ignore_patterns(path: str, names: List):  # pylint: disable=unused-argument
+        ignored_names = set()
+        if custom_file_filter.ignore_name_patterns is not None:
+            for pattern in custom_file_filter.ignore_name_patterns:
+                ignored_names.update(fnmatch.filter(names, pattern))
+        return ignored_names
+
+    def _filter_non_python_files(path: str, names: List) -> List:
+        """Ignore function for filtering out non python files."""
+        to_ignore = []
+        for name in names:
+            full_path = os.path.join(path, name)
+            if os.path.isfile(full_path):
+                if not name.endswith(".py"):
+                    to_ignore.append(name)
+            elif os.path.isdir(full_path):
+                if name == "__pycache__":
+                    to_ignore.append(name)
+            else:
+                to_ignore.append(name)
+
+        return to_ignore
+
+    _ignore = None
+    _src = os.getcwd()
+    if not custom_file_filter:
+        _ignore = _filter_non_python_files
+    elif callable(custom_file_filter):
+        _ignore = custom_file_filter
+    elif isinstance(custom_file_filter, CustomFileFilter):
+        _ignore = _ignore_patterns
+        _src = custom_file_filter.workdir
+
+    shutil.copytree(
+        _src,
+        dst,
+        ignore=_ignore,
+    )

sagemaker/core/remote_function/errors.py

@@ -0,0 +1,104 @@
+# 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.
+"""Definitions for reomote job errors and error handling"""
+from __future__ import absolute_import
+
+import os
+
+from tblib import pickling_support
+from sagemaker.core.s3 import s3_path_join
+import sagemaker.core.remote_function.core.serialization as serialization
+
+
+DEFAULT_FAILURE_CODE = 1
+FAILURE_REASON_PATH = "/opt/ml/output/failure"
+
+
+@pickling_support.install
+class RemoteFunctionError(Exception):
+    """The base exception class for remote function exceptions"""
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+@pickling_support.install
+class ServiceError(RemoteFunctionError):
+    """Raised when errors encountered during interaction with SageMaker, S3 service APIs"""
+
+
+@pickling_support.install
+class SerializationError(RemoteFunctionError):
+    """Raised when errors encountered during serialization of remote function objects"""
+
+
+@pickling_support.install
+class DeserializationError(RemoteFunctionError):
+    """Raised when errors encountered during deserialization of remote function objects"""
+
+
+def _get_valid_failure_exit_code(exit_code) -> int:
+    """Normalize exit code for terminating the process"""
+    try:
+        valid_exit_code = int(exit_code)
+    except (TypeError, ValueError):
+        valid_exit_code = DEFAULT_FAILURE_CODE
+
+    return valid_exit_code
+
+
+def _write_failure_reason_file(failure_msg):
+    """Create a file 'failure' with failure reason written if remote function execution failed.
+
+    See: https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html
+    Args:
+        failure_msg: The content of file to be written.
+    """
+    if not os.path.exists(FAILURE_REASON_PATH):
+        with open(FAILURE_REASON_PATH, "w") as f:
+            f.write(failure_msg)
+
+
+def handle_error(error, sagemaker_session, s3_base_uri, s3_kms_key, hmac_key) -> int:
+    """Handle all exceptions raised during remote function execution.
+
+    Args:
+        error (Exception): The error to be handled.
+        sagemaker_session (sagemaker.core.helper.session.Session): The underlying Boto3 session which
+             AWS service calls are delegated to.
+        s3_base_uri (str): S3 root uri to which resulting serialized exception will be uploaded.
+        s3_kms_key (str): KMS key used to encrypt artifacts uploaded to S3.
+        hmac_key (str): Key used to calculate hmac hash of the serialized exception.
+    Returns :
+        exit_code (int): Exit code to terminate current job.
+    """
+
+    failure_reason = repr(error)
+    if isinstance(error, RemoteFunctionError):
+        exit_code = DEFAULT_FAILURE_CODE
+    else:
+        error_number = getattr(error, "errno", DEFAULT_FAILURE_CODE)
+        exit_code = _get_valid_failure_exit_code(error_number)
+
+    _write_failure_reason_file(failure_reason)
+
+    serialization.serialize_exception_to_s3(
+        exc=error,
+        sagemaker_session=sagemaker_session,
+        s3_uri=s3_path_join(s3_base_uri, "exception"),
+        hmac_key=hmac_key,
+        s3_kms_key=s3_kms_key,
+    )
+
+    return exit_code

sagemaker/core/remote_function/invoke_function.py

@@ -0,0 +1,172 @@
+# 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.
+"""An entry point for invoking remote function inside a job."""
+
+from __future__ import absolute_import
+
+import argparse
+import sys
+import json
+import os
+from typing import TYPE_CHECKING
+
+import boto3
+from sagemaker.core.remote_function.job import (
+    KEY_EXPERIMENT_NAME,
+    KEY_RUN_NAME,
+)
+
+from sagemaker.core.helper.session_helper import Session
+from sagemaker.core.s3 import s3_path_join
+from sagemaker.core.remote_function.errors import handle_error
+from sagemaker.core.remote_function import logging_config
+from sagemaker.core.remote_function.core.pipeline_variables import Context
+
+if TYPE_CHECKING:
+    from sagemaker.core.experiments.run import Run
+
+
+SUCCESS_EXIT_CODE = 0
+
+
+def _parse_args(args):
+    """Parses CLI arguments."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--region", type=str, required=True)
+    parser.add_argument("--s3_base_uri", type=str, required=True)
+    parser.add_argument("--s3_kms_key", type=str)
+    parser.add_argument("--run_in_context", type=str)
+    parser.add_argument("--pipeline_step_name", type=str)
+    parser.add_argument("--pipeline_execution_id", type=str)
+    parser.add_argument("--property_references", nargs="+", type=str, default=[])
+    parser.add_argument(
+        "--serialize_output_to_json", default=False, type=lambda x: (str(x).lower() == "true")
+    )
+    parser.add_argument("--func_step_s3_dir", type=str)
+
+    args, _ = parser.parse_known_args(args)
+    return args
+
+
+def _get_sagemaker_session(region):
+    """Get sagemaker session for interacting with AWS or Sagemaker services"""
+    boto_session = boto3.session.Session(region_name=region)
+    return Session(boto_session=boto_session)
+
+
+def _load_run_object(run_in_context: str, sagemaker_session: Session) -> "Run":
+    """Load current run in json string into run object"""
+    from sagemaker.core.experiments.run import Run
+
+    run_dict = json.loads(run_in_context)
+    return Run(
+        experiment_name=run_dict.get(KEY_EXPERIMENT_NAME),
+        run_name=run_dict.get(KEY_RUN_NAME),
+        sagemaker_session=sagemaker_session,
+    )
+
+
+def _load_pipeline_context(args) -> Context:
+    """Load pipeline build or run context into context object"""
+
+    pipeline_step_name = args.pipeline_step_name
+    pipeline_execution_id = args.pipeline_execution_id
+    property_references = args.property_references
+    serialize_output_to_json = args.serialize_output_to_json
+    func_step_s3_dir = args.func_step_s3_dir
+
+    property_references_dict = {}
+    for i in range(0, len(property_references), 2):
+        property_references_dict[property_references[i]] = property_references[i + 1]
+    return Context(
+        step_name=pipeline_step_name,
+        execution_id=pipeline_execution_id,
+        property_references=property_references_dict,
+        serialize_output_to_json=serialize_output_to_json,
+        func_step_s3_dir=func_step_s3_dir,
+    )
+
+
+def _execute_remote_function(
+    sagemaker_session, s3_base_uri, s3_kms_key, run_in_context, hmac_key, context
+):
+    """Execute stored remote function"""
+    from sagemaker.core.remote_function.core.stored_function import StoredFunction
+
+    stored_function = StoredFunction(
+        sagemaker_session=sagemaker_session,
+        s3_base_uri=s3_base_uri,
+        s3_kms_key=s3_kms_key,
+        hmac_key=hmac_key,
+        context=context,
+    )
+
+    if run_in_context:
+        run_obj = _load_run_object(run_in_context, sagemaker_session)
+        with run_obj:
+            stored_function.load_and_invoke()
+    else:
+        stored_function.load_and_invoke()
+
+
+def main(sys_args=None):
+    """Entry point for invoke function script
+
+    Args:
+        sys_args (list): List of arguments to parse. If not specified, sys.argv is used.
+    """
+
+    logger = logging_config.get_logger()
+
+    exit_code = SUCCESS_EXIT_CODE
+
+    try:
+        args = _parse_args(sys_args)
+        region = args.region
+        s3_base_uri = args.s3_base_uri
+        s3_kms_key = args.s3_kms_key
+        run_in_context = args.run_in_context
+        pipeline_context = _load_pipeline_context(args)
+
+        hmac_key = os.getenv("REMOTE_FUNCTION_SECRET_KEY")
+
+        sagemaker_session = _get_sagemaker_session(region)
+        _execute_remote_function(
+            sagemaker_session=sagemaker_session,
+            s3_base_uri=s3_base_uri,
+            s3_kms_key=s3_kms_key,
+            run_in_context=run_in_context,
+            hmac_key=hmac_key,
+            context=pipeline_context,
+        )
+
+    except Exception as e:  # pylint: disable=broad-except
+        logger.exception("Error encountered while invoking the remote function.")
+        s3_uri = (
+            s3_path_join(s3_base_uri, pipeline_context.execution_id, pipeline_context.step_name)
+            if pipeline_context.step_name
+            else s3_base_uri
+        )
+        exit_code = handle_error(
+            error=e,
+            sagemaker_session=sagemaker_session,
+            s3_base_uri=s3_uri,
+            s3_kms_key=s3_kms_key,
+            hmac_key=hmac_key,
+        )
+    finally:
+        sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])