


import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()




def     UpperCamelCase    (      _a       ,		_a       ,		_a		)					->							Any:
     '''simple docstring'''





     lowercase_       :int     =       TaConfig.from_json_file(_a		)
     print(f"Building PyTorch model from configuration: {config}"		)
     lowercase_       :Tuple     =       TaForConditionalGeneration(_a		)

     # Load weights from tf checkpoint
     load_tf_weights_in_ta(_a       ,		_a       ,		_a		)

     # Save pytorch-model
     print(f"Save PyTorch model to {pytorch_dump_path}"		)
     model.save_pretrained(_a		)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE       :		Union[str, Any]         =				argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
   )
   parser.add_argument(
       "--config_file",
       default=None,
       type=str,
       required=True,
       help=(
           "The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture."
       ),
   )
   parser.add_argument(
       "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
   )
   SCREAMING_SNAKE_CASE       :		Union[str, Any]         =				parser.parse_args()
   convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)





from __future__ import annotations




def     UpperCamelCase    (      _a       ,		_a = None       ,		_a = None		)					->							None:
     '''simple docstring'''





     if start is None:
          lowercase_       :str     =       0

     if end is None:
          lowercase_       :str     =       len(_a		) - 1

     if start >= end:
          return

     lowercase_       :Dict     =       (start + end) // 2

     slowsort(_a       ,		_a       ,		_a		)
     slowsort(_a       ,		mid + 1       ,		_a		)

     if sequence[end] < sequence[mid]:
          lowercase_    ,      lowercase_       :List[Any]     =       sequence[mid], sequence[end]

     slowsort(_a       ,		_a       ,		end - 1		)


if __name__ == "__main__":
   from doctest import testmod

   testmod()

