






# 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 				lowerCamelCase__      (    __lowerCamelCase			:     List[str]		):
  __UpperCAmelCase							:	Optional[Any]           =  botoa.client("""iam"""		)

  __UpperCAmelCase							:	int           =  {
      """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=__lowerCamelCase  ,		AssumeRolePolicyDocument=json.dumps(__lowerCamelCase  ,		indent=2		)		)
    __UpperCAmelCase							:	List[str]           =  {
        """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=__lowerCamelCase  ,		PolicyName=f"""{role_name}_policy_permission"""  ,		PolicyDocument=json.dumps(__lowerCamelCase  ,		indent=2		)  ,		)
  except iam_client.exceptions.EntityAlreadyExistsException:
    print(f"""role {role_name} already exists. Using existing one"""		)






def 				lowerCamelCase__      (    __lowerCamelCase			:     List[Any]		):
  __UpperCAmelCase							:	Union[str, Any]           =  botoa.client("""iam"""		)
  return iam_client.get_role(RoleName=__lowerCamelCase		)["Role"]["Arn"]







def 				lowerCamelCase__      (    ):
  __UpperCAmelCase							:	List[str]           =  _ask_options(
      """How do you want to authorize?"""  ,		["""AWS Profile""", """Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) """]  ,		__lowerCamelCase  ,		)
  __UpperCAmelCase							:	Tuple           =  None
  if credentials_configuration == 0:
    __UpperCAmelCase							:	Dict           =  _ask_field("""Enter your AWS Profile name: [default] """  ,		default="""default"""		)
    __UpperCAmelCase							:	int           =  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`"""		)
    __UpperCAmelCase							:	Optional[Any]           =  _ask_field("""AWS Access Key ID: """		)
    __UpperCAmelCase							:	Dict           =  aws_access_key_id

    __UpperCAmelCase							:	Dict           =  _ask_field("""AWS Secret Access Key: """		)
    __UpperCAmelCase							:	Optional[int]           =  aws_secret_access_key

  __UpperCAmelCase							:	Dict           =  _ask_field("""Enter your AWS Region: [us-east-1]"""  ,		default="""us-east-1"""		)
  __UpperCAmelCase							:	List[str]           =  aws_region

  __UpperCAmelCase							:	List[str]           =  _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"""]  ,		__lowerCamelCase  ,		)
  if role_management == 0:
    __UpperCAmelCase							:	str           =  _ask_field("""Enter your IAM role name: """		)
  else:
    __UpperCAmelCase							:	int           =  """accelerate_sagemaker_execution_role"""
    print(f"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""		)
    _create_iam_role_for_sagemaker(__lowerCamelCase		)

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

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

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

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

    if use_custom_options:
      __UpperCAmelCase							:	Union[str, Any]           =  _ask_options(
          """Which mode do you want to use?"""  ,		__lowerCamelCase  ,		lambda __lowerCamelCase		: TORCH_DYNAMO_MODES[int(__lowerCamelCase		)]  ,		default="""default"""  ,		)
      __UpperCAmelCase							:	Any           =  _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=__lowerCamelCase  ,		error_message="""Please enter yes or no."""  ,		)
      __UpperCAmelCase							:	Union[str, Any]           =  _ask_field(
          """Do you want to enable dynamic shape tracing? [yes/NO]: """  ,		_convert_yes_no_to_bool  ,		default=__lowerCamelCase  ,		error_message="""Please enter yes or no."""  ,		)
  __UpperCAmelCase							:	Any           =  """Which EC2 instance type you want to use for your training?"""
  if distributed_type != SageMakerDistributedType.NO:
    __UpperCAmelCase							:	Tuple           =  _ask_options(
        __lowerCamelCase  ,		__lowerCamelCase  ,		lambda __lowerCamelCase		: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(__lowerCamelCase		)]		)
  else:
    eca_instance_query += "? [ml.p3.2xlarge]:"
    __UpperCAmelCase							:	List[Any]           =  _ask_field(__lowerCamelCase  ,		lambda __lowerCamelCase		: str(__lowerCamelCase		).lower()  ,		default="""ml.p3.2xlarge"""		)

  __UpperCAmelCase							:	List[Any]           =  1
  if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
    __UpperCAmelCase							:	Optional[Any]           =  _ask_field(
        """How many machines do you want use? [1]: """  ,		__lowerCamelCase  ,		default=1  ,		)

  __UpperCAmelCase							:	str           =  _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=__lowerCamelCase  ,		compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER  ,		distributed_type=__lowerCamelCase  ,		use_cpu=__lowerCamelCase  ,		dynamo_config=__lowerCamelCase  ,		eca_instance_type=__lowerCamelCase  ,		profile=__lowerCamelCase  ,		region=__lowerCamelCase  ,		iam_role_name=__lowerCamelCase  ,		mixed_precision=__lowerCamelCase  ,		num_machines=__lowerCamelCase  ,		sagemaker_inputs_file=__lowerCamelCase  ,		sagemaker_metrics_file=__lowerCamelCase  ,		)










from math import log

from scipy.constants import Boltzmann, physical_constants

a		:       Any			     = 300  # TEMPERATURE (unit = K)






def 				lowerCamelCase__      (    __lowerCamelCase			:     float  ,		__lowerCamelCase			:     float  ,		__lowerCamelCase			:     float  ,		):

  if donor_conc <= 0:
    raise ValueError("""Donor concentration should be positive"""		)
  elif acceptor_conc <= 0:
    raise ValueError("""Acceptor concentration should be positive"""		)
  elif intrinsic_conc <= 0:
    raise ValueError("""Intrinsic concentration should be positive"""		)
  elif donor_conc <= intrinsic_conc:
    raise ValueError(
        """Donor concentration should be greater than intrinsic concentration"""		)
  elif acceptor_conc <= intrinsic_conc:
    raise ValueError(
        """Acceptor concentration should be greater than intrinsic concentration"""		)
  else:
    return (
        Boltzmann
        * T
        * log((donor_conc * acceptor_conc) / intrinsic_conc**2		)
        / physical_constants["electron volt"][0]
    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()


