

# Copyright 2021 The HuggingFace Team. 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.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License 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.
import json
import os

from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES
from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
from ...utils.imports import is_botoa_available
from .config_args import SageMakerConfig
from .config_utils import (
    DYNAMO_BACKENDS,
    _ask_field,
    _ask_options,
    _convert_dynamo_backend,
    _convert_mixed_precision,
    _convert_sagemaker_distributed_mode,
    _convert_yes_no_to_bool,
)


if is_botoa_available():
		import botoa  # noqa: F401


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							botoa.client('iam'      )

					__lowerCAmelCase					=							{
					    'Version': '2012-10-17',
					    'Statement': [
					        {'Effect': 'Allow', 'Principal': {'Service': 'sagemaker.amazonaws.com'}, 'Action': 'sts:AssumeRole'}
					    ],
					}
					try:
										# create the role, associated with the chosen trust policy
										iam_client.create_role(
										    RoleName=UpperCAmelCase__		,					AssumeRolePolicyDocument=json.dumps(UpperCAmelCase__		,					indent=2      )      )
										__lowerCAmelCase					=							{
										    'Version': '2012-10-17',
										    'Statement': [
										        {
										            'Effect': 'Allow',
										            'Action': [
										                'sagemaker:*',
										                'ecr:GetDownloadUrlForLayer',
										                'ecr:BatchGetImage',
										                'ecr:BatchCheckLayerAvailability',
										                'ecr:GetAuthorizationToken',
										                'cloudwatch:PutMetricData',
										                'cloudwatch:GetMetricData',
										                'cloudwatch:GetMetricStatistics',
										                'cloudwatch:ListMetrics',
										                'logs:CreateLogGroup',
										                'logs:CreateLogStream',
										                'logs:DescribeLogStreams',
										                'logs:PutLogEvents',
										                'logs:GetLogEvents',
										                's3:CreateBucket',
										                's3:ListBucket',
										                's3:GetBucketLocation',
										                's3:GetObject',
										                's3:PutObject',
										            ],
										            'Resource': '*',
										        }
										    ],
										}
										# attach policy to role
										iam_client.put_role_policy(
										    RoleName=UpperCAmelCase__		,					PolicyName=F"""{role_name}_policy_permission"""		,					PolicyDocument=json.dumps(UpperCAmelCase__		,					indent=2      )		,					)
					except iam_client.exceptions.EntityAlreadyExistsException:
										print(F"""role {role_name} already exists. Using existing one"""      )


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							botoa.client('iam'      )
					return iam_client.get_role(RoleName=UpperCAmelCase__      )["Role"]["Arn"]


def        __lowercase    (  ):

					"""simple docstring"""






					__lowerCAmelCase					=							_ask_options(
					    'How do you want to authorize?'		,					['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']		,					UpperCAmelCase__		,					)
					__lowerCAmelCase					=							None
					if credentials_configuration == 0:
										__lowerCAmelCase					=							_ask_field('Enter your AWS Profile name: [default] '		,					default='default'      )
										__lowerCAmelCase					=							aws_profile
					else:
										print(
										    'Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,'
										    '`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`'      )
										__lowerCAmelCase					=							_ask_field('AWS Access Key ID: '      )
										__lowerCAmelCase					=							aws_access_key_id

										__lowerCAmelCase					=							_ask_field('AWS Secret Access Key: '      )
										__lowerCAmelCase					=							aws_secret_access_key

					__lowerCAmelCase					=							_ask_field('Enter your AWS Region: [us-east-1]'		,					default='us-east-1'      )
					__lowerCAmelCase					=							aws_region

					__lowerCAmelCase					=							_ask_options(
					    'Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?'		,					['Provide IAM Role name', 'Create new IAM role using credentials']		,					UpperCAmelCase__		,					)
					if role_management == 0:
										__lowerCAmelCase					=							_ask_field('Enter your IAM role name: '      )
					else:
										__lowerCAmelCase					=							'accelerate_sagemaker_execution_role'
										print(F"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""      )
										_create_iam_role_for_sagemaker(UpperCAmelCase__      )

					__lowerCAmelCase					=							_ask_field(
					    'Do you want to use custom Docker image? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
					__lowerCAmelCase					=							None
					if is_custom_docker_image:
										__lowerCAmelCase					=							_ask_field('Enter your Docker image: '		,					lambda UpperCAmelCase__      : str(UpperCAmelCase__      ).lower()      )

					__lowerCAmelCase					=							_ask_field(
					    'Do you want to provide SageMaker input channels with data locations? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
					__lowerCAmelCase					=							None
					if is_sagemaker_inputs_enabled:
										__lowerCAmelCase					=							_ask_field(
										    'Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): '		,					lambda UpperCAmelCase__      : str(UpperCAmelCase__      ).lower()		,					)

					__lowerCAmelCase					=							_ask_field(
					    'Do you want to enable SageMaker metrics? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
					__lowerCAmelCase					=							None
					if is_sagemaker_metrics_enabled:
										__lowerCAmelCase					=							_ask_field(
										    'Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): '		,					lambda UpperCAmelCase__      : str(UpperCAmelCase__      ).lower()		,					)

					__lowerCAmelCase					=							_ask_options(
					    'What is the distributed mode?'		,					['No distributed training', 'Data parallelism']		,					_convert_sagemaker_distributed_mode		,					)
					__lowerCAmelCase					=							{}
					__lowerCAmelCase					=							_ask_field(
					    'Do you wish to optimize your script with torch dynamo?[yes/NO]:'		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
					if use_dynamo:
										__lowerCAmelCase					=							'dynamo_'
										__lowerCAmelCase					=							_ask_options(
										    'Which dynamo backend would you like to use?'		,					[x.lower() for x in DYNAMO_BACKENDS]		,					_convert_dynamo_backend		,					default=2		,					)
										__lowerCAmelCase					=							_ask_field(
										    'Do you want to customize the defaults sent to torch.compile? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)

										if use_custom_options:
															__lowerCAmelCase					=							_ask_options(
															    'Which mode do you want to use?'		,					UpperCAmelCase__		,					lambda UpperCAmelCase__      : TORCH_DYNAMO_MODES[int(UpperCAmelCase__      )]		,					default='default'		,					)
															__lowerCAmelCase					=							_ask_field(
															    'Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
															__lowerCAmelCase					=							_ask_field(
															    'Do you want to enable dynamic shape tracing? [yes/NO]: '		,					_convert_yes_no_to_bool		,					default=UpperCAmelCase__		,					error_message='Please enter yes or no.'		,					)
					__lowerCAmelCase					=							'Which EC2 instance type you want to use for your training?'
					if distributed_type != SageMakerDistributedType.NO:
										__lowerCAmelCase					=							_ask_options(
										    UpperCAmelCase__		,					UpperCAmelCase__		,					lambda UpperCAmelCase__      : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(UpperCAmelCase__      )]      )
					else:
										eca_instance_query += "? [ml.p3.2xlarge]:"
										__lowerCAmelCase					=							_ask_field(UpperCAmelCase__		,					lambda UpperCAmelCase__      : str(UpperCAmelCase__      ).lower()		,					default='ml.p3.2xlarge'      )

					__lowerCAmelCase					=							1
					if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
										__lowerCAmelCase					=							_ask_field(
										    'How many machines do you want use? [1]: '		,					UpperCAmelCase__		,					default=1		,					)

					__lowerCAmelCase					=							_ask_options(
					    'Do you wish to use FP16 or BF16 (mixed precision)?'		,					['no', 'fp16', 'bf16', 'fp8']		,					_convert_mixed_precision		,					)

					if use_dynamo and mixed_precision == "no":
										print(
										    'Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts.'      )

					return SageMakerConfig(
					    image_uri=UpperCAmelCase__		,					compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER		,					distributed_type=UpperCAmelCase__		,					use_cpu=UpperCAmelCase__		,					dynamo_config=UpperCAmelCase__		,					eca_instance_type=UpperCAmelCase__		,					profile=UpperCAmelCase__		,					region=UpperCAmelCase__		,					iam_role_name=UpperCAmelCase__		,					mixed_precision=UpperCAmelCase__		,					num_machines=UpperCAmelCase__		,					sagemaker_inputs_file=UpperCAmelCase__		,					sagemaker_metrics_file=UpperCAmelCase__		,					)









import hashlib
import unittest

from transformers import MODEL_FOR_DEPTH_ESTIMATION_MAPPING, is_torch_available, is_vision_available
from transformers.pipelines import DepthEstimationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image
else:





		class     snake_case_			:


									"""simple docstring"""





									@staticmethod
									def        A__  ( *_A					,						**_A							):
														pass


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							hashlib.mda(image.tobytes()      )
					return m.hexdigest()





@is_pipeline_test
@require_vision
@require_timm
@require_torch
class     snake_case_			(				unittest.TestCase							):


							"""simple docstring"""





							__UpperCAmelCase       =MODEL_FOR_DEPTH_ESTIMATION_MAPPING




							def        A__  ( self					,						_A					,						_A					,						_A							):
												__lowerCAmelCase					=							DepthEstimationPipeline(model=_A					,						image_processor=_A							)
												return depth_estimator, [
												    "./tests/fixtures/tests_samples/COCO/000000039769.png",
												    "./tests/fixtures/tests_samples/COCO/000000039769.png",
												]




							def        A__  ( self					,						_A					,						_A							):
												__lowerCAmelCase					=							depth_estimator('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
												self.assertEqual({'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)}					,						_A							)
												import datasets

												__lowerCAmelCase					=							datasets.load_dataset('hf-internal-testing/fixtures_image_utils'					,						'image'					,						split='test'							)
												__lowerCAmelCase					=							depth_estimator(
												    [
												        Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							),
												        'http://images.cocodataset.org/val2017/000000039769.jpg',
												        # RGBA
												        dataset[0]['file'],
												        # LA
												        dataset[1]['file'],
												        # L
												        dataset[2]['file'],
												    ]							)
												self.assertEqual(
												    [
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												    ]					,						_A					,						)




							@require_tf
							@unittest.skip('Depth estimation is not implemented in TF'							)
							def        A__  ( self							):
												pass




							@slow
							@require_torch
							def        A__  ( self							):
												__lowerCAmelCase					=							'Intel/dpt-large'
												__lowerCAmelCase					=							pipeline('depth-estimation'					,						model=_A							)
												__lowerCAmelCase					=							depth_estimator('http://images.cocodataset.org/val2017/000000039769.jpg'							)
												__lowerCAmelCase					=							hashimage(outputs['depth']							)

												# This seems flaky.
												# self.assertEqual(outputs["depth"], "1a39394e282e9f3b0741a90b9f108977")
												self.assertEqual(nested_simplify(outputs['predicted_depth'].max().item()							)					,						29.304							)
												self.assertEqual(nested_simplify(outputs['predicted_depth'].min().item()							)					,						2.662							)




							@require_torch
							def        A__  ( self							):
												# This is highly irregular to have no small tests.
												self.skipTest('There is not hf-internal-testing tiny model for either GLPN nor DPT'							)






