


import argparse
import collections
import os
import re

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_table.py
UpperCAmelCase__   	=							'''src/transformers'''
UpperCAmelCase__   	=							'''docs/source/en'''
UpperCAmelCase__   	=							'''.'''
def 				UpperCAmelCase_					(							__snake_case     ,						__snake_case     ,						__snake_case						)     ->			List[Any]:







 """simple docstring"""


 with open(__snake_case     ,						'''r'''     ,						encoding='''utf-8'''     ,						newline='''\n'''						) as f:
  _lowercase							      =f.readlines()
 # Find the start prompt.
 _lowercase							      =0
 while not lines[start_index].startswith(__snake_case						):
  start_index += 1
 start_index += 1

 _lowercase							      =start_index
 while not lines[end_index].startswith(__snake_case						):
  end_index += 1
 end_index -= 1

 while len(lines[start_index]						) <= 1:
  start_index += 1
 while len(lines[end_index]						) <= 1:
  end_index -= 1
 end_index += 1
 return "".join(lines[start_index:end_index]						), start_index, end_index, lines


# Add here suffixes that are used to identify models, separated by |
UpperCAmelCase__   	=							'''Model|Encoder|Decoder|ForConditionalGeneration'''
# Regexes that match TF/Flax/PT model names.
UpperCAmelCase__   	=							re.compile(R'''TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')
UpperCAmelCase__   	=							re.compile(R'''Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
UpperCAmelCase__   	=							re.compile(R'''(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')


# This is to make sure the transformers module imported is the one in the repo.
UpperCAmelCase__   	=							direct_transformers_import(TRANSFORMERS_PATH)
def 				UpperCAmelCase_					(							__snake_case						)     ->			Tuple:







 """simple docstring"""


 _lowercase							      =re.finditer('''.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)'''     ,						__snake_case						)
 return [m.group(0						) for m in matches]
def 				UpperCAmelCase_					(							__snake_case     ,						__snake_case						)     ->			str:







 """simple docstring"""


 _lowercase							      =2 if text == '''✅''' or text == '''❌''' else len(__snake_case						)
 _lowercase							      =(width - text_length) // 2
 _lowercase							      =width - text_length - left_indent
 return " " * left_indent + text + " " * right_indent
def 				UpperCAmelCase_					(							)     ->			Optional[Any]:







 """simple docstring"""


 _lowercase							      =transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
 _lowercase							      ={
     name: config_maping_names[code]
     for code, name in transformers_module.MODEL_NAMES_MAPPING.items()
     if code in config_maping_names
 }
 _lowercase							      ={name: config.replace('''Config'''     ,						''''''						) for name, config in model_name_to_config.items()}

 # Dictionaries flagging if each model prefix has a slow/fast tokenizer, backend in PT/TF/Flax.
 _lowercase							      =collections.defaultdict(__snake_case						)
 _lowercase							      =collections.defaultdict(__snake_case						)
 _lowercase							      =collections.defaultdict(__snake_case						)
 _lowercase							      =collections.defaultdict(__snake_case						)
 _lowercase							      =collections.defaultdict(__snake_case						)

 # Let's lookup through all transformers object (once).
 for attr_name in dir(__snake_case						):
  _lowercase							      =None
  if attr_name.endswith('''Tokenizer'''						):
   _lowercase							      =slow_tokenizers
   _lowercase							      =attr_name[:-9]
  elif attr_name.endswith('''TokenizerFast'''						):
   _lowercase							      =fast_tokenizers
   _lowercase							      =attr_name[:-13]
  elif _re_tf_models.match(__snake_case						) is not None:
   _lowercase							      =tf_models
   _lowercase							      =_re_tf_models.match(__snake_case						).groups()[0]
  elif _re_flax_models.match(__snake_case						) is not None:
   _lowercase							      =flax_models
   _lowercase							      =_re_flax_models.match(__snake_case						).groups()[0]
  elif _re_pt_models.match(__snake_case						) is not None:
   _lowercase							      =pt_models
   _lowercase							      =_re_pt_models.match(__snake_case						).groups()[0]

  if lookup_dict is not None:
   while len(__snake_case						) > 0:
    if attr_name in model_name_to_prefix.values():
     _lowercase							      =True
     break
    # Try again after removing the last word in the name
    _lowercase							      =''''''.join(camel_case_split(__snake_case						)[:-1]						)

    # Let's build that table!
 _lowercase							      =list(model_name_to_config.keys()						)
 model_names.sort(key=str.lower						)
 _lowercase							      =['''Model''', '''Tokenizer slow''', '''Tokenizer fast''', '''PyTorch support''', '''TensorFlow support''', '''Flax Support''']
 # We'll need widths to properly display everything in the center (+2 is to leave one extra space on each side).
 _lowercase							      =[len(__snake_case						) + 2 for c in columns]
 _lowercase							      =max([len(__snake_case						) for name in model_names]						) + 2

 # Build the table per se
 _lowercase							      ='''|''' + '''|'''.join([_center_text(__snake_case     ,						__snake_case						) for c, w in zip(__snake_case     ,						__snake_case						)]						) + '''|\n'''
 # Use ":-----:" format to center-aligned table cell texts
 table += "|" + "|".join([''':''' + '''-''' * (w - 2) + ''':''' for w in widths]						) + "|\n"

 _lowercase							      ={True: '''✅''', False: '''❌'''}
 for name in model_names:
  _lowercase							      =model_name_to_prefix[name]
  _lowercase							      =[
      name,
      check[slow_tokenizers[prefix]],
      check[fast_tokenizers[prefix]],
      check[pt_models[prefix]],
      check[tf_models[prefix]],
      check[flax_models[prefix]],
  ]
  table += "|" + "|".join([_center_text(__snake_case     ,						__snake_case						) for l, w in zip(__snake_case     ,						__snake_case						)]						) + "|\n"
 return table
def 				UpperCAmelCase_					(							__snake_case=False						)     ->			List[str]:







 """simple docstring"""


 _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase							      =_find_text_in_file(
     filename=os.path.join(__snake_case     ,						'''index.md'''						)     ,						start_prompt='''<!--This table is updated automatically from the auto modules'''     ,						end_prompt='''<!-- End table-->'''     ,						)
 _lowercase							      =get_model_table_from_auto_modules()

 if current_table != new_table:
  if overwrite:
   with open(os.path.join(__snake_case     ,						'''index.md'''						)     ,						'''w'''     ,						encoding='''utf-8'''     ,						newline='''\n'''						) as f:
    f.writelines(lines[:start_index] + [new_table] + lines[end_index:]						)
  else:
   raise ValueError(
       '''The model table in the `index.md` has not been updated. Run `make fix-copies` to fix this.'''						)


if __name__ == "__main__":
  UpperCAmelCase__   	=							argparse.ArgumentParser()
  parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
  UpperCAmelCase__   	=							parser.parse_args()

  check_model_table(args.fix_and_overwrite)


"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__					       =	logging.get_logger(__name__)

lowercase__					       =	{
    'MIT/ast-finetuned-audioset-10-10-0.4593': (
        'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
    ),
}




class    __snake_case       (     __lowerCAmelCase				):
      a__        =		"""audio-spectrogram-transformer"""



      def __init__(						self    ,			lowercase=7_68    ,			lowercase=12    ,			lowercase=12    ,			lowercase=30_72    ,			lowercase="gelu"    ,			lowercase=0.0    ,			lowercase=0.0    ,			lowercase=0.02    ,			lowercase=1e-12    ,			lowercase=16    ,			lowercase=True    ,			lowercase=10    ,			lowercase=10    ,			lowercase=10_24    ,			lowercase=1_28    ,			**lowercase    ,			)	->			str:





        '''simple docstring'''





        super().__init__(**lowercase)

        a__:     Any										=	hidden_size
        a__:     int										=	num_hidden_layers
        a__:     Union[str, Any]										=	num_attention_heads
        a__:     Any										=	intermediate_size
        a__:     Union[str, Any]										=	hidden_act
        a__:     int										=	hidden_dropout_prob
        a__:     str										=	attention_probs_dropout_prob
        a__:     str										=	initializer_range
        a__:     Tuple										=	layer_norm_eps
        a__:     Any										=	patch_size
        a__:     int										=	qkv_bias
        a__:     Optional[Any]										=	frequency_stride
        a__:     int										=	time_stride
        a__:     List[str]										=	max_length
        a__:     Tuple										=	num_mel_bins


