





"""simple docstring"""
# 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 					A__				(			UpperCamelCase       ):
							A		=  botoa.client("iam"       )

							A		=  {
							    "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       )       )
														A		=  {
														    "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 					A__				(			UpperCamelCase       ):
							A		=  botoa.client("iam"       )
							return iam_client.get_role(RoleName=UpperCamelCase       )["Role"]["Arn"]






def 					A__				(			):
							A		=  _ask_options(
							    "How do you want to authorize?"					,  ["AWS Profile", "Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) "]					,  UpperCamelCase					,  )
							A		=  None
							if credentials_configuration == 0:
														A		=  _ask_field("Enter your AWS Profile name: [default] "					,  default="default"       )
														A		=  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`"       )
														A		=  _ask_field("AWS Access Key ID: "       )
														A		=  aws_access_key_id

														A		=  _ask_field("AWS Secret Access Key: "       )
														A		=  aws_secret_access_key

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

							A		=  _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:
														A		=  _ask_field("Enter your IAM role name: "       )
							else:
														A		=  "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       )

							A		=  _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."					,  )
							A		=  None
							if is_custom_docker_image:
														A		=  _ask_field("Enter your Docker image: "					,  lambda UpperCamelCase       : str(UpperCamelCase       ).lower()       )

							A		=  _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."					,  )
							A		=  None
							if is_sagemaker_inputs_enabled:
														A		=  _ask_field(
														    "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "					,  lambda UpperCamelCase       : str(UpperCamelCase       ).lower()					,  )

							A		=  _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."					,  )
							A		=  None
							if is_sagemaker_metrics_enabled:
														A		=  _ask_field(
														    "Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): "					,  lambda UpperCamelCase       : str(UpperCamelCase       ).lower()					,  )

							A		=  _ask_options(
							    "What is the distributed mode?"					,  ["No distributed training", "Data parallelism"]					,  _convert_sagemaker_distributed_mode					,  )
							A		=  {}
							A		=  _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:
														A		=  "dynamo_"
														A		=  _ask_options(
														    "Which dynamo backend would you like to use?"					,  [x.lower() for x in DYNAMO_BACKENDS]					,  _convert_dynamo_backend					,  default=2					,  )
														A		=  _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:
																					A		=  _ask_options(
																					    "Which mode do you want to use?"					,  UpperCamelCase					,  lambda UpperCamelCase       : TORCH_DYNAMO_MODES[int(UpperCamelCase       )]					,  default="default"					,  )
																					A		=  _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."					,  )
																					A		=  _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."					,  )
							A		=  "Which EC2 instance type you want to use for your training?"
							if distributed_type != SageMakerDistributedType.NO:
														A		=  _ask_options(
														    UpperCamelCase					,  UpperCamelCase					,  lambda UpperCamelCase       : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(UpperCamelCase       )]       )
							else:
														eca_instance_query += "? [ml.p3.2xlarge]:"
														A		=  _ask_field(UpperCamelCase					,  lambda UpperCamelCase       : str(UpperCamelCase       ).lower()					,  default="ml.p3.2xlarge"       )

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

							A		=  _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					,  )









"""simple docstring"""
import math
import sys






def 					A__				(			UpperCamelCase       ):
							A		=  ""
							try:
														with open(UpperCamelCase					,  "rb"       ) as binary_file:
																					A		=  binary_file.read()
														for dat in data:
																					A		=  F"{dat:08b}"
																					result += curr_byte
														return result
							except OSError:
														print("File not accessible"       )
														sys.exit()






def 					A__				(			UpperCamelCase       ):
							A		=  {"0": "0", "1": "1"}
							A,	A		=  "", ""
							A		=  len(UpperCamelCase       )

							for i in range(len(UpperCamelCase       )       ):
														curr_string += data_bits[i]
														if curr_string not in lexicon:
																					continue

														A		=  lexicon[curr_string]
														result += last_match_id
														A		=  last_match_id + "0"

														if math.loga(UpperCamelCase       ).is_integer():
																					A		=  {}
																					for curr_key in list(UpperCamelCase       ):
																												A		=  lexicon.pop(UpperCamelCase       )
																					A		=  new_lex

														A		=  last_match_id + "1"
														index += 1
														A		=  ""
							return result






def 					A__				(			UpperCamelCase					,  UpperCamelCase       ):
							A		=  8
							try:
														with open(UpperCamelCase					,  "wb"       ) as opened_file:
																					A		=  [
																					    to_write[i : i + byte_length]
																					    for i in range(0					,  len(UpperCamelCase       )					,  UpperCamelCase       )
																					]

																					if len(result_byte_array[-1]       ) % byte_length == 0:
																												result_byte_array.append("10000000"       )
																					else:
																												result_byte_array[-1] += "1" + "0" * (
																												    byte_length - len(result_byte_array[-1]       ) - 1
																												)

																					for elem in result_byte_array[:-1]:
																												opened_file.write(int(UpperCamelCase					,  2       ).to_bytes(1					,  byteorder="big"       )       )
							except OSError:
														print("File not accessible"       )
														sys.exit()






def 					A__				(			UpperCamelCase       ):
							A		=  0
							for letter in data_bits:
														if letter == "1":
																					break
														counter += 1

							A		=  data_bits[counter:]
							A		=  data_bits[counter + 1 :]
							return data_bits






def 					A__				(			UpperCamelCase					,  UpperCamelCase       ):
							A		=  read_file_binary(UpperCamelCase       )
							A		=  remove_prefix(UpperCamelCase       )
							A		=  decompress_data(UpperCamelCase       )
							write_file_binary(UpperCamelCase					,  UpperCamelCase       )


if __name__ == "__main__":
		compress(sys.argv[1], sys.argv[2])


