
'''simple docstring'''





import re

from flax.core.frozen_dict import freeze
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.experimental import PartitionSpec as P


# Sentinels
a__						:      Optional[Any]   				=				object()

# For specifying empty leaf dict `{}`
a__						:      Dict   				=				object()





def 				snake_case							(						UpperCAmelCase					,     UpperCAmelCase		)->	Tuple:







      """simple docstring"""
      __A						=	tuple((re.compile(x + '$'		) for x in qs)		)
      for i in range(len(snake_case__		) - len(snake_case__		) + 1		):
            __A						=	[x.match(snake_case__		) for x, y in zip(snake_case__					,     ks[i:]		)]
            if matches and all(snake_case__		):
                  return True
      return False





def 				snake_case							(						UpperCAmelCase		)->	Optional[int]:







      """simple docstring"""
      def replace(UpperCAmelCase					,     UpperCAmelCase		):
            for rule, replacement in rules:
                  if _match(snake_case__					,     snake_case__		):
                        return replacement
            return val

      return replace





def 				snake_case							(						)->	Tuple:







      """simple docstring"""
      return [
          # embeddings
          (("transformer", "wpe", "embedding"), P('mp'					,     snake_case__		)),
          (("transformer", "wte", "embedding"), P('mp'					,     snake_case__		)),
          # atention
          (("attention", "(q_proj|k_proj|v_proj)", "kernel"), P(snake_case__					,     'mp'		)),
          (("attention", "out_proj", "kernel"), P('mp'					,     snake_case__		)),
          (("attention", "out_proj", "bias"), None),
          # mlp
          (("mlp", "c_fc", "kernel"), P(snake_case__					,     'mp'		)),
          (("mlp", "c_fc", "bias"), P('mp'		)),
          (("mlp", "c_proj", "kernel"), P('mp'					,     snake_case__		)),
          (("mlp", "c_proj", "bias"), None),
          # layer norms
          ((r"ln_\d+", "bias"), None),
          ((r"\d+", r"ln_\d+", "scale"), None),
          (("ln_f", "bias"), None),
          (("ln_f", "scale"), None),
      ]





def 				snake_case							(						UpperCAmelCase		)->	List[Any]:







      """simple docstring"""
      __A						=	_get_partition_rules()
      __A						=	_replacement_rules(snake_case__		)
      __A						=	{k: _unmatched for k in flatten_dict(snake_case__		)}
      __A						=	{k: replace(snake_case__					,     snake_case__		) for k, v in initd.items()}
      assert _unmatched not in result.values(), "Incomplete partition spec."
      return freeze(unflatten_dict(snake_case__		)		)







def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       _A        =  set()

       # Replace all the whitespace in our sentence
       _A        =  input_str.replace(""" """   ,	"""""")
       for alpha in input_str:
              if "a" <= alpha.lower() <= "z":
                     frequency.add(alpha.lower())
       return len(snake_case__) == 26






def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       _A        =  [False] * 26
       for char in input_str:
              if char.islower():
                     _A        =  True
              elif char.isupper():
                     _A        =  True
       return all(snake_case__)






def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       return len({char for char in input_str.lower() if char.isalpha()}) == 26






def  snake_case  (       )						->   None:
       from timeit import timeit

       _A        =  """from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"""
       print(timeit("""is_pangram()"""   ,	setup=snake_case__))
       print(timeit("""is_pangram_faster()"""   ,	setup=snake_case__))
       print(timeit("""is_pangram_fastest()"""   ,	setup=snake_case__))
       # 5.348480500048026, 2.6477354579837993, 1.8470395830227062
       # 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()




