





"""simple docstring"""





import argparse
import os
import re


__A											=		"""src/transformers/models/auto"""


# re pattern that matches mapping introductions:
#    SUPER_MODEL_MAPPING_NAMES = OrderedDict or SUPER_MODEL_MAPPING = OrderedDict
__A											=		re.compile(R"""[A-Z_]+_MAPPING(\s+|_[A-Z_]+\s+)=\s+OrderedDict""")
# re pattern that matches identifiers in mappings
__A											=		re.compile(R"""\s*\(\s*\"(\S[^\"]+)\"""")
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE = False			)					->Any:





  """simple docstring"""


  with open(_SCREAMING_SNAKE_CASE     ,   'r'     ,   encoding='utf-8'			) as f:
    lowerCAmelCase__			:Tuple											=							f.read()

  lowerCAmelCase__			:Optional[Any]											=							content.split('\n'			)
  lowerCAmelCase__			:Any											=							[]
  lowerCAmelCase__			:Tuple											=							0
  while line_idx < len(_SCREAMING_SNAKE_CASE			):
    if _re_intro_mapping.search(lines[line_idx]			) is not None:
      lowerCAmelCase__			:Optional[Any]											=							len(re.search(r'^(\s*)\S'     ,   lines[line_idx]			).groups()[0]			) + 8
      # Start of a new mapping!
      while not lines[line_idx].startswith(' ' * indent + '('			):
        new_lines.append(lines[line_idx]			)
        line_idx += 1

      lowerCAmelCase__			:Any											=							[]
      while lines[line_idx].strip() != "]":
        # Blocks either fit in one line or not
        if lines[line_idx].strip() == "(":
          lowerCAmelCase__			:List[str]											=							line_idx
          while not lines[line_idx].startswith(' ' * indent + ')'			):
            line_idx += 1
          blocks.append('\n'.join(lines[start_idx : line_idx + 1]			)			)
        else:
          blocks.append(lines[line_idx]			)
        line_idx += 1

      # Sort blocks by their identifiers
      lowerCAmelCase__			:List[Any]											=							sorted(_SCREAMING_SNAKE_CASE     ,   key=lambda _SCREAMING_SNAKE_CASE			: _re_identifier.search(_SCREAMING_SNAKE_CASE			).groups()[0]			)
      new_lines += blocks
    else:
      new_lines.append(lines[line_idx]			)
      line_idx += 1

  if overwrite:
    with open(_SCREAMING_SNAKE_CASE     ,   'w'     ,   encoding='utf-8'			) as f:
      f.write('\n'.join(_SCREAMING_SNAKE_CASE			)			)
  elif "\n".join(_SCREAMING_SNAKE_CASE			) != content:
    return True
def  __A   (_SCREAMING_SNAKE_CASE = False			)					->List[str]:





  """simple docstring"""


  lowerCAmelCase__			:Union[str, Any]											=							[os.path.join(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			) for f in os.listdir(_SCREAMING_SNAKE_CASE			) if f.endswith('.py'			)]
  lowerCAmelCase__			:List[str]											=							[sort_auto_mapping(_SCREAMING_SNAKE_CASE     ,   overwrite=_SCREAMING_SNAKE_CASE			) for fname in fnames]

  if not overwrite and any(_SCREAMING_SNAKE_CASE			):
    lowerCAmelCase__			:Optional[Any]											=							[f for f, d in zip(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			) if d]
    raise ValueError(
        F"The following files have auto mappings that need sorting: {', '.join(_SCREAMING_SNAKE_CASE			)}. Run `make style` to fix"
        ' this.'			)


if __name__ == "__main__":
  __A											=		argparse.ArgumentParser()
  parser.add_argument("""--check_only""", action="""store_true""", help="""Whether to only check or fix style.""")
  __A											=		parser.parse_args()

  sort_all_auto_mappings(not args.check_only)







"""simple docstring"""





import math
def  __A   (_SCREAMING_SNAKE_CASE			)					->int:





  """simple docstring"""


  if not isinstance(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			):
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be an integer"
    raise TypeError(_SCREAMING_SNAKE_CASE			)

  if number < 1:
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be > 0"
    raise ValueError(_SCREAMING_SNAKE_CASE			)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    lowerCAmelCase__			:Union[str, Any]											=							int(math.log(number // 3     ,   2			)			) + 2

    lowerCAmelCase__			:Optional[Any]											=							[3, 5]
    lowerCAmelCase__			:Optional[Any]											=							2
    lowerCAmelCase__			:List[str]											=							3
    for block in range(1     ,   _SCREAMING_SNAKE_CASE			):
      for _ in range(_SCREAMING_SNAKE_CASE			):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]			)
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for number in range(11):
    __A											=		0
    try:
      __A											=		proth(number)
    except ValueError:
      print(F'''ValueError: there is no {number}th Proth number''')
      continue

    print(F'''The {number}th Proth number: {value}''')
