





from timeit import timeit

_lowerCAmelCase				:   Tuple						       =						{
    '''MALAYALAM''': True,
    '''String''': False,
    '''rotor''': True,
    '''level''': True,
    '''A''': True,
    '''BB''': True,
    '''ABC''': False,
    '''amanaplanacanalpanama''': True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					List[str]        =      0
   A_       :					str        =      len(_lowerCAmelCase						) - 1
   while start_i < end_i:
      if s[start_i] == s[end_i]:
         start_i += 1
         end_i -= 1
      else:
         return False
   return True

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					int        =      len(_lowerCAmelCase						) // 2
   A_       :					Union[str, Any]        =      len(_lowerCAmelCase						)

   # We need to traverse till half of the length of string
   # as we can get access of the i'th last element from
   # i'th index.
   # eg: [0,1,2,3,4,5] => 4th index can be accessed
   # with the help of 1st index (i==n-i-1)
   # where n is length of string
   return all(s[i] == s[n - i - 1] for i in range(_lowerCAmelCase						)						)

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   if len(_lowerCAmelCase						) <= 2:
      return True
   if s[0] == s[len(_lowerCAmelCase						) - 1]:
      return is_palindrome_recursive(s[1:-1]						)
   else:
      return False

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   return s == s[::-1]

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    None:
   A_       :					int        =      f"all({name}(key) is value for key, value in test_data.items())"
   A_       :					List[str]        =      f"from __main__ import test_data, {name}"
   A_       :					str        =      500000
   A_       :					List[str]        =      timeit(stmt=_lowerCAmelCase					,					setup=_lowerCAmelCase					,					number=_lowerCAmelCase						)
   print(f"{name:<35} finished {number:,} runs in {result:.5f} seconds"						)


if __name__ == "__main__":
 for key, value in test_data.items():
  assert is_palindrome(key) is is_palindrome_recursive(key)
  assert is_palindrome(key) is is_palindrome_slice(key)
  print(F'''{key:21} {value}''')
 print('''a man a plan a canal panama''')

 # finished 500,000 runs in 0.46793 seconds
 benchmark_function('''is_palindrome_slice''')
 # finished 500,000 runs in 0.85234 seconds
 benchmark_function('''is_palindrome''')
 # finished 500,000 runs in 1.32028 seconds
 benchmark_function('''is_palindrome_recursive''')
 # finished 500,000 runs in 2.08679 seconds
 benchmark_function('''is_palindrome_traversal''')







from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxSeqaSeqConfigWithPast
from ...utils import logging


_lowerCAmelCase				:   Optional[int]						       =						logging.get_logger(__name__)

_lowerCAmelCase				:   List[str]						       =						{
    '''google/umt5-small''': '''https://huggingface.co/google/umt5-small/resolve/main/config.json''',
    # See all umt5 models at https://huggingface.co/models?filter=umt5
}


class        __magic_name__	(				lowerCamelCase__				):





     """simple docstring"""



     __UpperCamelCase            =  '''umt5'''
     __UpperCamelCase            =  ['''past_key_values''']



     def __init__(				self							:int      ,   snake_case							:Optional[Any]=250_112      ,   snake_case							:Optional[int]=512      ,   snake_case							:Any=64      ,   snake_case							:Union[str, Any]=1_024      ,   snake_case							:Tuple=8      ,   snake_case							:Optional[int]=None      ,   snake_case							:Union[str, Any]=6      ,   snake_case							:List[Any]=32      ,   snake_case							:Dict=128      ,   snake_case							:List[str]=0.1      ,   snake_case							:List[Any]=1e-6      ,   snake_case							:Dict=1.0      ,   snake_case							:Union[str, Any]="gated-gelu"      ,   snake_case							:Union[str, Any]=True      ,   snake_case							:Any=True      ,   snake_case							:List[str]="T5Tokenizer"      ,   snake_case							:Union[str, Any]=True      ,   snake_case							:Union[str, Any]=0      ,   snake_case							:List[Any]=1      ,   snake_case							:List[Any]=0      ,   **snake_case							:Any      ,   ):





        '''simple docstring'''




        super().__init__(
            is_encoder_decoder=snake_case      ,   tokenizer_class=snake_case      ,   tie_word_embeddings=snake_case      ,   pad_token_id=snake_case      ,   eos_token_id=snake_case      ,   decoder_start_token_id=snake_case      ,   **snake_case      ,   )
        A_       :					Union[str, Any]        =      vocab_size
        A_       :					Tuple        =      d_model
        A_       :					List[str]        =      d_kv
        A_       :					Union[str, Any]        =      d_ff
        A_       :					Any        =      num_layers
        A_       :					Optional[Any]        =      (
            num_decoder_layers if num_decoder_layers is not None else self.num_layers
        )  # default = symmetry
        A_       :					List[Any]        =      num_heads
        A_       :					List[str]        =      relative_attention_num_buckets
        A_       :					Dict        =      relative_attention_max_distance
        A_       :					Optional[Any]        =      dropout_rate
        A_       :					Any        =      layer_norm_epsilon
        A_       :					List[Any]        =      initializer_factor
        A_       :					Any        =      feed_forward_proj
        A_       :					Optional[Any]        =      use_cache

        A_       :					int        =      self.feed_forward_proj.split("-"	)
        A_       :					Any        =      act_info[-1]
        A_       :					Tuple        =      act_info[0] == "gated"

        if len(snake_case	) > 1 and act_info[0] != "gated" or len(snake_case	) > 2:
           raise ValueError(
               f"`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."
               "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
               "'gated-gelu' or 'relu'"	)

        if feed_forward_proj == "gated-gelu":
           A_       :					Optional[Any]        =      "gelu_new"



     @property
     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        return self.d_model



     @property
     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        return self.num_heads





     @property
     def     SCREAMING_SNAKE_CASE		(				self							:Tuple	):





        '''simple docstring'''




        return self.num_layers




class        __magic_name__	(				lowerCamelCase__				):





     """simple docstring"""



     @property
     # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        A_       :					List[Any]        =      {
            "input_ids": {0: "batch", 1: "encoder_sequence"},
            "attention_mask": {0: "batch", 1: "encoder_sequence"},
        }
        if self.use_past:
           A_       :					Any        =      "past_encoder_sequence + sequence"
           A_       :					Union[str, Any]        =      {0: "batch"}
           A_       :					Optional[int]        =      {0: "batch", 1: "past_decoder_sequence + sequence"}
        else:
           A_       :					Dict        =      {0: "batch", 1: "decoder_sequence"}
           A_       :					str        =      {0: "batch", 1: "decoder_sequence"}

        if self.use_past:
           self.fill_with_past_key_values_(snake_case      ,   direction="inputs"	)

        return common_inputs



     @property
     # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        return 13





     @property
     def     SCREAMING_SNAKE_CASE		(				self							:List[str]	):





        '''simple docstring'''




        return 5e-4
