import argparse

import torch

from transformers import (
    SpeechTaConfig,
    SpeechTaFeatureExtractor,
    SpeechTaForSpeechToSpeech,
    SpeechTaForSpeechToText,
    SpeechTaForTextToSpeech,
    SpeechTaProcessor,
    SpeechTaTokenizer,
    logging,
)
from transformers.tokenization_utils import AddedToken


logging.set_verbosity_info()
UpperCAmelCase_			    =							logging.get_logger('''transformers.models.speecht5''')

UpperCAmelCase_			    =							{
    '''speech_encoder_prenet.layer_norm''': '''speecht5.encoder.prenet.feature_projection.layer_norm''',
    '''speech_encoder_prenet.post_extract_proj''': '''speecht5.encoder.prenet.feature_projection.projection''',
    '''speech_encoder_prenet.pos_conv.0''': '''speecht5.encoder.prenet.pos_conv_embed.conv''',
    '''speech_encoder_prenet.mask_emb''': '''speecht5.encoder.prenet.masked_spec_embed''',
}
UpperCAmelCase_			    =							{
    '''text_encoder_prenet.encoder_prenet.0''': '''speecht5.encoder.prenet.embed_tokens''',
    '''text_encoder_prenet.encoder_prenet.1.alpha''': '''speecht5.encoder.prenet.encode_positions.alpha''',
}
UpperCAmelCase_			    =							{
    '''speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0''': '''speecht5.decoder.prenet.layers.0''',
    '''speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0''': '''speecht5.decoder.prenet.layers.1''',
    '''speech_decoder_prenet.decoder_prenet.0.1''': '''speecht5.decoder.prenet.final_layer''',
    '''speech_decoder_prenet.decoder_prenet.1.alpha''': '''speecht5.decoder.prenet.encode_positions.alpha''',
    '''speech_decoder_prenet.spkembs_layer.0''': '''speecht5.decoder.prenet.speaker_embeds_layer''',
}
UpperCAmelCase_			    =							{
    '''speech_decoder_postnet.feat_out''': '''speech_decoder_postnet.feat_out''',
    '''speech_decoder_postnet.prob_out''': '''speech_decoder_postnet.prob_out''',
    '''speech_decoder_postnet.postnet.postnet.0.0''': '''speech_decoder_postnet.layers.0.conv''',
    '''speech_decoder_postnet.postnet.postnet.0.1''': '''speech_decoder_postnet.layers.0.batch_norm''',
    '''speech_decoder_postnet.postnet.postnet.1.0''': '''speech_decoder_postnet.layers.1.conv''',
    '''speech_decoder_postnet.postnet.postnet.1.1''': '''speech_decoder_postnet.layers.1.batch_norm''',
    '''speech_decoder_postnet.postnet.postnet.2.0''': '''speech_decoder_postnet.layers.2.conv''',
    '''speech_decoder_postnet.postnet.postnet.2.1''': '''speech_decoder_postnet.layers.2.batch_norm''',
    '''speech_decoder_postnet.postnet.postnet.3.0''': '''speech_decoder_postnet.layers.3.conv''',
    '''speech_decoder_postnet.postnet.postnet.3.1''': '''speech_decoder_postnet.layers.3.batch_norm''',
    '''speech_decoder_postnet.postnet.postnet.4.0''': '''speech_decoder_postnet.layers.4.conv''',
    '''speech_decoder_postnet.postnet.postnet.4.1''': '''speech_decoder_postnet.layers.4.batch_norm''',
}
UpperCAmelCase_			    =							{
    '''text_decoder_prenet.embed_tokens''': '''speecht5.decoder.prenet.embed_tokens''',
}
UpperCAmelCase_			    =							{
    '''text_decoder_postnet.output_projection''': '''text_decoder_postnet.lm_head''',
}
UpperCAmelCase_			    =							{
    '''encoder.layers.*.self_attn.k_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj''',
    '''encoder.layers.*.self_attn.v_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj''',
    '''encoder.layers.*.self_attn.q_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj''',
    '''encoder.layers.*.self_attn.out_proj''': '''speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj''',
    '''encoder.layers.*.self_attn_layer_norm''': '''speecht5.encoder.wrapped_encoder.layers.*.layer_norm''',
    '''encoder.layers.*.fc1''': '''speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense''',
    '''encoder.layers.*.fc2''': '''speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense''',
    '''encoder.layers.*.final_layer_norm''': '''speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''speecht5.encoder.wrapped_encoder.layer_norm''',
    '''encoder.pos_emb.pe_k''': '''speecht5.encoder.wrapped_encoder.embed_positions.pe_k''',
}
UpperCAmelCase_			    =							{
    '''decoder.layers.*.self_attn.k_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj''',
    '''decoder.layers.*.self_attn.v_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj''',
    '''decoder.layers.*.self_attn.q_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj''',
    '''decoder.layers.*.self_attn.out_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj''',
    '''decoder.layers.*.self_attn_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm''',
    '''decoder.layers.*.encoder_attn.k_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj''',
    '''decoder.layers.*.encoder_attn.v_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj''',
    '''decoder.layers.*.encoder_attn.q_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj''',
    '''decoder.layers.*.encoder_attn.out_proj''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj''',
    '''decoder.layers.*.encoder_attn_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm''',
    '''decoder.layers.*.fc1''': '''speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense''',
    '''decoder.layers.*.fc2''': '''speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense''',
    '''decoder.layers.*.final_layer_norm''': '''speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm''',
}
UpperCAmelCase_			    =							{
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_TEXT_DECODER_PRENET,
    **MAPPING_TEXT_DECODER_POSTNET,
}
UpperCAmelCase_			    =							{
    **MAPPING_TEXT_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
UpperCAmelCase_			    =							{
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
UpperCAmelCase_			    =							[]
UpperCAmelCase_			    =							[
    '''encoder.version''',
    '''encoder.layers.*.norm_k.weight''',
    '''encoder.layers.*.norm_k.bias''',
    '''decoder.version''',
    '''decoder.layers.*.norm_k.weight''',
    '''decoder.layers.*.norm_k.bias''',
    '''decoder.pos_emb.pe_k''',
    '''speech_encoder_prenet.embed_positions._float_tensor''',
    '''text_decoder_prenet.embed_positions._float_tensor''',
]
UpperCAmelCase_			    =							IGNORE_KEYS + [
    '''encoder.proj''',
    '''text_encoder_prenet.*''',
    '''speech_decoder_prenet.*''',
    '''speech_decoder_postnet.*''',
]
UpperCAmelCase_			    =							IGNORE_KEYS + [
    '''encoder.proj''',
    '''speech_encoder_prenet.*''',
    '''text_decoder_prenet.*''',
    '''text_decoder_postnet.*''',
]
UpperCAmelCase_			    =							IGNORE_KEYS + [
    '''encoder.proj''',
    '''text_encoder_prenet.*''',
    '''text_decoder_prenet.*''',
    '''text_decoder_postnet.*''',
]




def       lowerCAmelCase_     (		lowercase:							str  ,					lowercase:							int  ,					lowercase:							Optional[Any]  ,					lowercase:							int  ,					lowercase:							Optional[int]		)    ->				Union[str, Any]:







 '''simple docstring'''
 for attribute in key.split('''.'''		):
  _UpperCamelCase:     Optional[Any]							= getattr(lowercase  ,					lowercase		)

 if weight_type is not None:
  _UpperCamelCase:     Optional[Any]							= getattr(lowercase  ,					lowercase		).shape
 else:
  _UpperCamelCase:     str							= hf_pointer.shape

 if hf_shape != value.shape:
  raise ValueError(
      F"""Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"""
      F""" {value.shape} for {full_name}"""		)

 if weight_type == "weight":
  _UpperCamelCase:     Any							= value
 elif weight_type == "weight_g":
  _UpperCamelCase:     Optional[int]							= value
 elif weight_type == "weight_v":
  _UpperCamelCase:     Union[str, Any]							= value
 elif weight_type == "bias":
  _UpperCamelCase:     Optional[int]							= value
 elif weight_type == "running_mean":
  _UpperCamelCase:     Union[str, Any]							= value
 elif weight_type == "running_var":
  _UpperCamelCase:     Union[str, Any]							= value
 elif weight_type == "num_batches_tracked":
  _UpperCamelCase:     int							= value
 else:
  _UpperCamelCase:     str							= value

 logger.info(F"""{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}."""		)




def       lowerCAmelCase_     (		lowercase:							Any  ,					lowercase:							Any		)    ->				str:







 '''simple docstring'''
 for key in ignore_keys:
  if key.endswith('''.*'''		):
   if name.startswith(key[:-1]		):
    return True
  elif ".*." in key:
   _UpperCamelCase	,							_UpperCamelCase:     List[Any]							= key.split('''.*.'''		)
   if prefix in name and suffix in name:
    return True
  elif key in name:
   return True
 return False




def       lowerCAmelCase_     (		lowercase:							Tuple  ,					lowercase:							List[Any]  ,					lowercase:							int		)    ->				Optional[int]:







 '''simple docstring'''
 _UpperCamelCase:     Dict							= []

 if task == "s2t":
  _UpperCamelCase:     Union[str, Any]							= hf_model.speechta.encoder.prenet.feature_encoder
  _UpperCamelCase:     int							= MAPPING_S2T
  _UpperCamelCase:     Optional[int]							= IGNORE_KEYS_S2T
 elif task == "t2s":
  _UpperCamelCase:     Union[str, Any]							= None
  _UpperCamelCase:     List[Any]							= MAPPING_T2S
  _UpperCamelCase:     Any							= IGNORE_KEYS_T2S
 elif task == "s2s":
  _UpperCamelCase:     Optional[Any]							= hf_model.speechta.encoder.prenet.feature_encoder
  _UpperCamelCase:     Dict							= MAPPING_S2S
  _UpperCamelCase:     List[Any]							= IGNORE_KEYS_S2S
 else:
  raise ValueError(F"""Unsupported task: {task}"""		)

 for name, value in fairseq_dict.items():
  if should_ignore(lowercase  ,					lowercase		):
   logger.info(F"""{name} was ignored"""		)
   continue

  _UpperCamelCase:     Any							= False
  if "conv_layers" in name:
   load_conv_layer(
       lowercase  ,					lowercase  ,					lowercase  ,					lowercase  ,					hf_model.config.feat_extract_norm == '''group'''  ,					)
   _UpperCamelCase:     Optional[Any]							= True
  else:
   for key, mapped_key in MAPPING.items():
    # mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key

    if "*" in key:
     _UpperCamelCase	,							_UpperCamelCase:     List[Any]							= key.split('''.*.'''		)
     if prefix in name and suffix in name:
      _UpperCamelCase:     List[str]							= suffix

                # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
    if key in name:
     _UpperCamelCase:     Optional[int]							= True
     if "*" in mapped_key:
      _UpperCamelCase:     Tuple							= name.split(lowercase		)[0].split('''.'''		)[-2]
      _UpperCamelCase:     Tuple							= mapped_key.replace('''*'''  ,					lowercase		)
     if "weight_g" in name:
      _UpperCamelCase:     Any							= '''weight_g'''
     elif "weight_v" in name:
      _UpperCamelCase:     Dict							= '''weight_v'''
     elif "bias" in name:
      _UpperCamelCase:     Union[str, Any]							= '''bias'''
     elif "weight" in name:
      _UpperCamelCase:     Optional[Any]							= '''weight'''
     elif "running_mean" in name:
      _UpperCamelCase:     Dict							= '''running_mean'''
     elif "running_var" in name:
      _UpperCamelCase:     Dict							= '''running_var'''
     elif "num_batches_tracked" in name:
      _UpperCamelCase:     Optional[Any]							= '''num_batches_tracked'''
     else:
      _UpperCamelCase:     str							= None
     set_recursively(lowercase  ,					lowercase  ,					lowercase  ,					lowercase  ,					lowercase		)
    continue
  if not is_used:
   unused_weights.append(lowercase		)

 logger.warning(F"""Unused weights: {unused_weights}"""		)




def       lowerCAmelCase_     (		lowercase:							Dict  ,					lowercase:							str  ,					lowercase:							Optional[int]  ,					lowercase:							Optional[int]  ,					lowercase:							str		)    ->				str:







 '''simple docstring'''
 _UpperCamelCase:     str							= full_name.split('''conv_layers.'''		)[-1]
 _UpperCamelCase:     Union[str, Any]							= name.split('''.'''		)
 _UpperCamelCase:     List[str]							= int(items[0]		)
 _UpperCamelCase:     int							= int(items[1]		)

 if type_id == 0:
  if "bias" in name:
   if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
    raise ValueError(
        F"""{full_name} has size {value.shape}, but"""
        F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""		)
   _UpperCamelCase:     Tuple							= value
   logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""		)
  elif "weight" in name:
   if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
    raise ValueError(
        F"""{full_name} has size {value.shape}, but"""
        F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""		)
   _UpperCamelCase:     Dict							= value
   logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""		)
 elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
  if "bias" in name:
   if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
    raise ValueError(
        F"""{full_name} has size {value.shape}, but"""
        F""" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."""		)
   _UpperCamelCase:     Optional[Any]							= value
   logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""		)
  elif "weight" in name:
   if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
    raise ValueError(
        F"""{full_name} has size {value.shape}, but"""
        F""" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."""		)
   _UpperCamelCase:     Tuple							= value
   logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""		)
 else:
  unused_weights.append(lowercase		)




@torch.no_grad()
def       lowerCAmelCase_     (		lowercase:							Optional[Any]  ,					lowercase:							Tuple  ,					lowercase:							Dict  ,					lowercase:							int=None  ,					lowercase:							int=None  ,					lowercase:							Optional[Any]=None  ,					)    ->				int:







 '''simple docstring'''
 if config_path is not None:
  _UpperCamelCase:     Tuple							= SpeechTaConfig.from_pretrained(lowercase		)
 else:
  _UpperCamelCase:     Optional[Any]							= SpeechTaConfig()

 if task == "s2t":
  _UpperCamelCase:     Tuple							= config.max_text_positions
  _UpperCamelCase:     Optional[int]							= SpeechTaForSpeechToText(lowercase		)
 elif task == "t2s":
  _UpperCamelCase:     str							= 1_876
  _UpperCamelCase:     int							= 600
  _UpperCamelCase:     Union[str, Any]							= config.max_speech_positions
  _UpperCamelCase:     Optional[int]							= SpeechTaForTextToSpeech(lowercase		)
 elif task == "s2s":
  _UpperCamelCase:     List[Any]							= 1_876
  _UpperCamelCase:     Dict							= config.max_speech_positions
  _UpperCamelCase:     Union[str, Any]							= SpeechTaForSpeechToSpeech(lowercase		)
 else:
  raise ValueError(F"""Unknown task name: {task}"""		)

 if vocab_path:
  _UpperCamelCase:     List[str]							= SpeechTaTokenizer(lowercase  ,					model_max_length=config.max_text_positions		)

  # Mask token behaves like a normal word, i.e. include the space before it
  _UpperCamelCase:     List[str]							= AddedToken('''<mask>'''  ,					lstrip=lowercase  ,					rstrip=lowercase		)
  _UpperCamelCase:     List[str]							= mask_token
  tokenizer.add_special_tokens({'''mask_token''': mask_token}		)
  tokenizer.add_tokens(['''<ctc_blank>''']		)

 _UpperCamelCase:     str							= SpeechTaFeatureExtractor()
 _UpperCamelCase:     List[str]							= SpeechTaProcessor(tokenizer=lowercase  ,					feature_extractor=lowercase		)
 processor.save_pretrained(lowercase		)

 _UpperCamelCase:     Any							= torch.load(lowercase		)
 recursively_load_weights(fairseq_checkpoint['''model''']  ,					lowercase  ,					lowercase		)

 model.save_pretrained(lowercase		)

 if repo_id:
  print('''Pushing to the hub...'''		)
  processor.push_to_hub(lowercase		)
  model.push_to_hub(lowercase		)


if __name__ == "__main__":
  UpperCAmelCase_			    =							argparse.ArgumentParser()
  parser.add_argument(
      '''--task''',
      default='''s2t''',
      type=str,
      help='''Type of the SpeechT5 model you\'d like to convert. Should be one of \'s2t\', \'t2s\', \'s2s\'.''',
  )
  parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to fairseq checkpoint''')
  parser.add_argument('''--vocab_path''', default=None, type=str, help='''Path to SentencePiece model''')
  parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
  parser.add_argument(
      '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.'''
  )
  parser.add_argument(
      '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.'''
  )

  UpperCAmelCase_			    =							parser.parse_args()
  convert_speechta_checkpoint(
      args.task,
      args.checkpoint_path,
      args.pytorch_dump_folder_path,
      args.config_path,
      args.vocab_path,
      args.push_to_hub,
  )
# 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 argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCAmelCase_			    =							[
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]




def       lowerCAmelCase_     (		lowercase:							str  ,					lowercase:							Optional[Any]=None  ,					lowercase:							List[str]=None  ,					lowercase:							List[str]=None		)    ->				Tuple:







 '''simple docstring'''
 _UpperCamelCase:     int							= True
 while ask_again:
  _UpperCamelCase:     Any							= input(lowercase		)
  try:
   if default is not None and len(lowercase		) == 0:
    return default
   return convert_value(lowercase		) if convert_value is not None else result
  except Exception:
   if error_message is not None:
    print(lowercase		)




def       lowerCAmelCase_     (		lowercase:							List[Any]  ,					lowercase:							Union[str, Any]=[]  ,					lowercase:							Union[str, Any]=None  ,					lowercase:							Union[str, Any]=0		)    ->				List[Any]:







 '''simple docstring'''
 _UpperCamelCase:     List[str]							= BulletMenu(lowercase  ,					lowercase		)
 _UpperCamelCase:     List[Any]							= menu.run(default_choice=lowercase		)
 return convert_value(lowercase		) if convert_value is not None else result




def       lowerCAmelCase_     (		lowercase:							Dict		)    ->				Optional[int]:







 '''simple docstring'''
 _UpperCamelCase:     int							= int(lowercase		)
 return ComputeEnvironment(['''LOCAL_MACHINE''', '''AMAZON_SAGEMAKER'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Tuple		)    ->				Any:







 '''simple docstring'''
 _UpperCamelCase:     str							= int(lowercase		)
 return DistributedType(['''NO''', '''MULTI_CPU''', '''MULTI_XPU''', '''MULTI_GPU''', '''MULTI_NPU''', '''TPU'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Union[str, Any]		)    ->				Optional[int]:







 '''simple docstring'''
 _UpperCamelCase:     Tuple							= int(lowercase		)
 return DynamoBackend(DYNAMO_BACKENDS[value]		).value




def       lowerCAmelCase_     (		lowercase:							int		)    ->				Any:







 '''simple docstring'''
 _UpperCamelCase:     int							= int(lowercase		)
 return PrecisionType(['''no''', '''fp16''', '''bf16''', '''fp8'''][value]		)




def       lowerCAmelCase_     (		lowercase:							List[str]		)    ->				List[str]:







 '''simple docstring'''
 _UpperCamelCase:     Dict							= int(lowercase		)
 return SageMakerDistributedType(['''NO''', '''DATA_PARALLEL''', '''MODEL_PARALLEL'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Any		)    ->				List[str]:







 '''simple docstring'''
 return {"yes": True, "no": False}[value.lower()]





class  __magic_name__  (		argparse.RawDescriptionHelpFormatter    ):





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  str		,  _lowercase					:  Optional[int]		,  _lowercase					:  List[Any]		,  _lowercase					:  Dict		,  _lowercase					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= super()._format_usage(_lowercase		,  _lowercase		,  _lowercase		,  _lowercase							)
    _UpperCamelCase:     int							= usage.replace('''<command> [<args>] '''		,  ''''''							)
    return usage