

import json
import os
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


_lowerCamelCase						    =  logging.get_logger(__name__)

_lowerCamelCase						    =  '''▁'''

_lowerCamelCase						    =  {
    '''vocab_file''': '''vocab.json''',
    '''spm_file''': '''sentencepiece.bpe.model''',
}

_lowerCamelCase						    =  {
    '''vocab_file''': {
        '''facebook/s2t-small-librispeech-asr''': (
            '''https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/vocab.json'''
        ),
    },
    '''spm_file''': {
        '''facebook/s2t-small-librispeech-asr''': (
            '''https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/sentencepiece.bpe.model'''
        )
    },
}

_lowerCamelCase						    =  {
    '''facebook/s2t-small-librispeech-asr''': 1024,
}

_lowerCamelCase						    =  ['''pt''', '''fr''', '''ru''', '''nl''', '''ro''', '''it''', '''es''', '''de''']

_lowerCamelCase						    =  {'''mustc''': MUSTC_LANGS}

class       _SCREAMING_SNAKE_CASE	(a__ ):
     lowerCAmelCase					=			VOCAB_FILES_NAMES
     lowerCAmelCase					=			PRETRAINED_VOCAB_FILES_MAP
     lowerCAmelCase					=			MAX_MODEL_INPUT_SIZES
     lowerCAmelCase					=			["""input_ids""", """attention_mask"""]

     lowerCAmelCase					=			[]





     def __init__(       self :							Optional[int]     ,  UpperCamelCase :							int     ,  UpperCamelCase :							Optional[Any]     ,  UpperCamelCase :							Optional[int]="<s>"     ,  UpperCamelCase :							List[Any]="</s>"     ,  UpperCamelCase :							Any="<pad>"     ,  UpperCamelCase :							Tuple="<unk>"     ,  UpperCamelCase :							List[str]=False     ,  UpperCamelCase :							Tuple=False     ,  UpperCamelCase :							int=None     ,  UpperCamelCase :							List[Any]=None     ,  UpperCamelCase :							Optional[Any] = None     ,  **UpperCamelCase :							Union[str, Any]     ,  )->None:
      __SCREAMING_SNAKE_CASE       :    str       =	{} if sp_model_kwargs is None else sp_model_kwargs

      super().__init__(
          bos_token=lowerCAmelCase__     ,  eos_token=lowerCAmelCase__     ,  unk_token=lowerCAmelCase__     ,  pad_token=lowerCAmelCase__     ,  do_upper_case=lowerCAmelCase__     ,  do_lower_case=lowerCAmelCase__     ,  tgt_lang=lowerCAmelCase__     ,  lang_codes=lowerCAmelCase__     ,  sp_model_kwargs=self.sp_model_kwargs     ,  **lowerCAmelCase__     ,  )
      __SCREAMING_SNAKE_CASE       :    Tuple       =	do_upper_case
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	do_lower_case

      __SCREAMING_SNAKE_CASE       :    List[str]       =	load_json(lowerCAmelCase__				)
      __SCREAMING_SNAKE_CASE       :    str       =	{v: k for k, v in self.encoder.items()}
      __SCREAMING_SNAKE_CASE       :    Tuple       =	spm_file
      __SCREAMING_SNAKE_CASE       :    int       =	load_spm(lowerCAmelCase__     ,  self.sp_model_kwargs				)

      if lang_codes is not None:
       __SCREAMING_SNAKE_CASE       :    List[Any]       =	lang_codes
       __SCREAMING_SNAKE_CASE       :    Any       =	LANGUAGES[lang_codes]
       __SCREAMING_SNAKE_CASE       :    Tuple       =	[F"""<lang:{lang}>""" for lang in self.langs]
       __SCREAMING_SNAKE_CASE       :    Tuple       =	{lang: self.sp_model.PieceToId(F"""<lang:{lang}>"""				) for lang in self.langs}

       __SCREAMING_SNAKE_CASE       :    Dict       =	self.lang_tokens
       __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	tgt_lang if tgt_lang is not None else self.langs[0]

       self.set_tgt_lang_special_tokens(self._tgt_lang				)
      else:
       __SCREAMING_SNAKE_CASE       :    Tuple       =	{}





     @property
     def 	__snake_case    (       self :							Union[str, Any]				)->int:
      return len(self.encoder				)





     @property
     def 	__snake_case    (       self :							List[str]				)->str:
      return self._tgt_lang





     @tgt_lang.setter
     def 	__snake_case    (       self :							str     ,  UpperCamelCase :							int				)->None:
      __SCREAMING_SNAKE_CASE       :    List[str]       =	new_tgt_lang
      self.set_tgt_lang_special_tokens(lowerCAmelCase__				)





     def 	__snake_case    (       self :							Optional[Any]     ,  UpperCamelCase :							List[str]				)->None:
      __SCREAMING_SNAKE_CASE       :    int       =	self.lang_code_to_id[tgt_lang]
      __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	[lang_code_id]





     def 	__snake_case    (       self :							Any     ,  UpperCamelCase :							Optional[int]				)->List[str]:
      return self.sp_model.encode(lowerCAmelCase__     ,  out_type=lowerCAmelCase__				)





     def 	__snake_case    (       self :							Dict     ,  UpperCamelCase :							List[Any]				)->Any:
      return self.encoder.get(lowerCAmelCase__     ,  self.encoder[self.unk_token]				)





     def 	__snake_case    (       self :							List[Any]     ,  UpperCamelCase :							Tuple				)->str:
      return self.decoder.get(lowerCAmelCase__     ,  self.unk_token				)





     def 	__snake_case    (       self :							Optional[int]     ,  UpperCamelCase :							str				)->str:
      __SCREAMING_SNAKE_CASE       :    int       =	[]
      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	""
      for token in tokens:
       # make sure that special tokens are not decoded using sentencepiece model
       if token in self.all_special_tokens:
        __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	self.sp_model.decode(lowerCAmelCase__				)
        out_string += (decoded.upper() if self.do_upper_case else decoded) + token + " "
        __SCREAMING_SNAKE_CASE       :    Any       =	[]
       else:
        current_sub_tokens.append(lowerCAmelCase__				)
      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	self.sp_model.decode(lowerCAmelCase__				)
      out_string += decoded.upper() if self.do_upper_case else decoded
      return out_string.strip()





     def 	__snake_case    (       self :							Dict     ,  UpperCamelCase :							List[Any]     ,  UpperCamelCase :							Union[str, Any]=None				)->List[int]:
      if token_ids_a is None:
       return self.prefix_tokens + token_ids_a + [self.eos_token_id]
      # We don't expect to process pairs, but leave the pair logic for API consistency
      return self.prefix_tokens + token_ids_a + token_ids_a + [self.eos_token_id]





     def 	__snake_case    (       self :							int     ,  UpperCamelCase :							Any     ,  UpperCamelCase :							List[Any] = None     ,  UpperCamelCase :							Any = False				)->List[int]:

      if already_has_special_tokens:
       return super().get_special_tokens_mask(
           token_ids_a=lowerCAmelCase__     ,  token_ids_a=lowerCAmelCase__     ,  already_has_special_tokens=lowerCAmelCase__				)

      __SCREAMING_SNAKE_CASE       :    int       =	[1] * len(self.prefix_tokens				)
      __SCREAMING_SNAKE_CASE       :    Tuple       =	[1]
      if token_ids_a is None:
       return prefix_ones + ([0] * len(lowerCAmelCase__				)) + suffix_ones
      return prefix_ones + ([0] * len(lowerCAmelCase__				)) + ([0] * len(lowerCAmelCase__				)) + suffix_ones





     def 	__snake_case    (       self :							List[str]				)->Dict:
      __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	self.encoder.copy()
      vocab.update(self.added_tokens_encoder				)
      return vocab





     def __getstate__(       self :							Any				)->Dict:
      __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	self.__dict__.copy()
      __SCREAMING_SNAKE_CASE       :    Dict       =	None
      return state





     def __setstate__(       self :							Tuple     ,  UpperCamelCase :							Dict				)->None:
      __SCREAMING_SNAKE_CASE       :    int       =	d

      # for backward compatibility
      if not hasattr(self     ,  "sp_model_kwargs"				):
       __SCREAMING_SNAKE_CASE       :    Optional[int]       =	{}

      __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	load_spm(self.spm_file     ,  self.sp_model_kwargs				)






     def 	__snake_case    (       self :							Any     ,  UpperCamelCase :							List[str]     ,  UpperCamelCase :							Tuple = None				)->Tuple[str]:
      __SCREAMING_SNAKE_CASE       :    str       =	Path(lowerCAmelCase__				)
      assert save_dir.is_dir(), F"""{save_directory} should be a directory"""
      __SCREAMING_SNAKE_CASE       :    Any       =	save_dir / (
          (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["vocab_file"]
      )
      __SCREAMING_SNAKE_CASE       :    Tuple       =	save_dir / (
          (filename_prefix + "-" if filename_prefix else "") + self.vocab_files_names["spm_file"]
      )

      save_json(self.encoder     ,  lowerCAmelCase__				)

      if os.path.abspath(self.spm_file				) != os.path.abspath(lowerCAmelCase__				) and os.path.isfile(self.spm_file				):
       copyfile(self.spm_file     ,  lowerCAmelCase__				)
      elif not os.path.isfile(self.spm_file				):
       with open(lowerCAmelCase__     ,  "wb"				) as fi:
        __SCREAMING_SNAKE_CASE       :    Optional[int]       =	self.sp_model.serialized_model_proto()
        fi.write(lowerCAmelCase__				)

      return (str(lowerCAmelCase__				), str(lowerCAmelCase__				))






def 	_lowerCAmelCase						(				__lowerCamelCase   :     str		,	__lowerCamelCase   :     Dict[str, Any]     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	sentencepiece.SentencePieceProcessor(**_lowercase     )
 spm.Load(str(_lowercase     )     )
 return spm






def 	_lowerCAmelCase						(				__lowerCamelCase   :     str     ):



 """simple docstring"""





 with open(_lowercase		,	"r"     ) as f:
  return json.load(_lowercase     )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Dict		,	__lowerCamelCase   :     str     ):



 """simple docstring"""





 with open(_lowercase		,	"w"     ) as f:
  json.dump(_lowercase		,	_lowercase		,	indent=2     )











# 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   :     Optional[int]     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	botoa.client("iam"     )

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	{
     "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     )     )
  __SCREAMING_SNAKE_CASE       :    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   :     Dict     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[str]       =	botoa.client("iam"     )
 return iam_client.get_role(RoleName=__lowerCamelCase     )["Role"]["Arn"]






def 	_lowerCAmelCase						(				):



 """simple docstring"""





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

  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_field("AWS Secret Access Key: "     )
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	aws_secret_access_key

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

 __SCREAMING_SNAKE_CASE       :    int       =	_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:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	_ask_field("Enter your IAM role name: "     )
 else:
  __SCREAMING_SNAKE_CASE       :    Any       =	"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     )

 __SCREAMING_SNAKE_CASE       :    Any       =	_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."		,	)
 __SCREAMING_SNAKE_CASE       :    Tuple       =	None
 if is_custom_docker_image:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	_ask_field("Enter your Docker image: "		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()     )

 __SCREAMING_SNAKE_CASE       :    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."		,	)
 __SCREAMING_SNAKE_CASE       :    List[Any]       =	None
 if is_sagemaker_inputs_enabled:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	_ask_field(
      "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()		,	)

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

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

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

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_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		,	)






