




'''simple docstring'''




import math
from timeit import timeit

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 UpperCAmelCase__										=    0
 UpperCAmelCase__										=    abs(SCREAMING_SNAKE_CASE__       )
 while True:
  UpperCAmelCase__										=    n // 10
  digits += 1
  if n == 0:
   break
 return digits

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 return 1 if n == 0 else math.floor(math.log(abs(SCREAMING_SNAKE_CASE__       )       ,						10       ) + 1       )

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 return len(str(abs(SCREAMING_SNAKE_CASE__       )       )       )

def    _UpperCamelCase      (				):
 '''simple docstring'''





 from collections.abc import Callable

 def benchmark_a_function(SCREAMING_SNAKE_CASE__			:      Callable       ,						SCREAMING_SNAKE_CASE__			:      int       ) -> None:
  UpperCAmelCase__										=    F'''{func.__name__}({value})'''
  UpperCAmelCase__										=    timeit(F'''__main__.{call}'''       ,						setup="""import __main__"""       )
  print(F'''{call}: {func(SCREAMING_SNAKE_CASE__       )} -- {timing} seconds'''       )

 for value in (262144, 1125899906842624, 1267650600228229401496703205376):
  for func in (num_digits, num_digits_fast, num_digits_faster):
   benchmark_a_function(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )
  print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()






'''simple docstring'''




import argparse

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


logging.set_verbosity_info()

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      List[str]       ,						SCREAMING_SNAKE_CASE__			:      str       ,						SCREAMING_SNAKE_CASE__			:      Tuple       ):
 '''simple docstring'''





 UpperCAmelCase__										=    TaConfig.from_json_file(SCREAMING_SNAKE_CASE__       )
 print(F'''Building PyTorch model from configuration: {config}'''       )
 UpperCAmelCase__										=    TaForConditionalGeneration(SCREAMING_SNAKE_CASE__       )

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

 # Save pytorch-model
 print(F'''Save PyTorch model to {pytorch_dump_path}'''       )
 model.save_pretrained(SCREAMING_SNAKE_CASE__       )


if __name__ == "__main__":
    UpperCAmelCase_       				=      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.'
    )
    UpperCAmelCase_       				=      parser.parse_args()
    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
