




'''simple docstring'''


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
_snake_case : Optional[int]  				=						'src/transformers'
_snake_case : str  				=						'docs/source/en'
_snake_case : Optional[Any]  				=						'.'
def 						snake_case_       (UpperCamelCase			:    Tuple					,		UpperCamelCase			:    str					,		UpperCamelCase			:    Tuple ):





							'''simple docstring'''


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

							_a      	=							start_index
							while not lines[end_index].startswith(UpperCamelCase ):
														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 |
_snake_case : List[str]  				=						'Model|Encoder|Decoder|ForConditionalGeneration'
# Regexes that match TF/Flax/PT model names.
_snake_case : Any  				=						re.compile(R'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
_snake_case : int  				=						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.
_snake_case : str  				=						re.compile(R'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')


# This is to make sure the transformers module imported is the one in the repo.
_snake_case : Optional[int]  				=						direct_transformers_import(TRANSFORMERS_PATH)
def 						snake_case_       (UpperCamelCase			:    List[str] ):





							'''simple docstring'''


							_a      	=							re.finditer('''.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)'''					,		UpperCamelCase )
							return [m.group(0 ) for m in matches]
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    Optional[Any] ):





							'''simple docstring'''


							_a      	=							2 if text == '''✅''' or text == '''❌''' else len(UpperCamelCase )
							_a      	=							(width - text_length) // 2
							_a      	=							width - text_length - left_indent
							return " " * left_indent + text + " " * right_indent
def 						snake_case_       ():





							'''simple docstring'''


							_a      	=							transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
							_a      	=							{
							    name: config_maping_names[code]
							    for code, name in transformers_module.MODEL_NAMES_MAPPING.items()
							    if code in config_maping_names
							}
							_a      	=							{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.
							_a      	=							collections.defaultdict(UpperCamelCase )
							_a      	=							collections.defaultdict(UpperCamelCase )
							_a      	=							collections.defaultdict(UpperCamelCase )
							_a      	=							collections.defaultdict(UpperCamelCase )
							_a      	=							collections.defaultdict(UpperCamelCase )

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

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

    # Let's build that table!
							_a      	=							list(model_name_to_config.keys() )
							model_names.sort(key=str.lower )
							_a      	=							['''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).
							_a      	=							[len(UpperCamelCase ) + 2 for c in columns]
							_a      	=							max([len(UpperCamelCase ) for name in model_names] ) + 2

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

							_a      	=							{True: '''✅''', False: '''❌'''}
							for name in model_names:
														_a      	=							model_name_to_prefix[name]
														_a      	=							[
														    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(UpperCamelCase					,		UpperCamelCase ) for l, w in zip(UpperCamelCase					,		UpperCamelCase )] ) + "|\n"
							return table
def 						snake_case_       (UpperCamelCase			:    str=False ):





							'''simple docstring'''


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

							if current_table != new_table:
														if overwrite:
																					with open(os.path.join(UpperCamelCase					,		'''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__":
				_snake_case : Dict  				=						argparse.ArgumentParser()
				parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
				_snake_case : Optional[Any]  				=						parser.parse_args()

				check_model_table(args.fix_and_overwrite)







'''simple docstring'''


from collections.abc import Generator
from math import sin
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) != 32:
														raise ValueError('''Input must be of length 32''' )

							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''08x''' )[-8:]
							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8''' )
							return little_endian_hex
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							B''''''
							for char in message:
														bit_string += format(UpperCamelCase					,		'''08b''' ).encode('''utf-8''' )
							_a      	=							format(len(UpperCamelCase )					,		'''064b''' ).encode('''utf-8''' )

							# Pad bit_string to a multiple of 512 chars
							bit_string += b"1"
							while len(UpperCamelCase ) % 512 != 448:
														bit_string += b"0"
							bit_string += to_little_endian(start_len[32:] ) + to_little_endian(start_len[:32] )

							return bit_string
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) % 512 != 0:
														raise ValueError('''Input must have length that\'s a multiple of 512''' )

							for pos in range(0					,		len(UpperCamelCase )					,		512 ):
														_a      	=							bit_string[pos : pos + 512]
														_a      	=							[]
														for i in range(0					,		512					,		32 ):
																					block_words.append(int(to_little_endian(block[i : i + 32] )					,		2 ) )
														yield block_words
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''032b''' )
							_a      	=							''''''
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(UpperCamelCase					,		2 )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							return (a + b) % 2**32
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )
							if shift < 0:
														raise ValueError('''Shift must be non-negative''' )
							return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							preprocess(UpperCamelCase )

							_a      	=							[int(2**32 * abs(sin(i + 1 ) ) ) for i in range(64 )]

							# Starting states
							_a      	=							0X67452301
							_a      	=							0Xefcdab89
							_a      	=							0X98badcfe
							_a      	=							0X10325476

							_a      	=							[
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							]

							# Process bit string in chunks, each with 16 32-char words
							for block_words in get_block_words(UpperCamelCase ):
														_a      	=							aa
														_a      	=							ba
														_a      	=							ca
														_a      	=							da

														# Hash current chunk
														for i in range(64 ):
																					if i <= 15:
																												# f = (b & c) | (not_32(b) & d)     # Alternate definition for f
																												_a      	=							d ^ (b & (c ^ d))
																												_a      	=							i
																					elif i <= 31:
																												# f = (d & b) | (not_32(d) & c)     # Alternate definition for f
																												_a      	=							c ^ (d & (b ^ c))
																												_a      	=							(5 * i + 1) % 16
																					elif i <= 47:
																												_a      	=							b ^ c ^ d
																												_a      	=							(3 * i + 5) % 16
																					else:
																												_a      	=							c ^ (b | not_aa(UpperCamelCase ))
																												_a      	=							(7 * i) % 16
																					_a      	=							(f + a + added_consts[i] + block_words[g]) % 2**32
																					_a      	=							d
																					_a      	=							c
																					_a      	=							b
																					_a      	=							sum_aa(UpperCamelCase					,		left_rotate_aa(UpperCamelCase					,		shift_amounts[i] ) )

														# Add hashed chunk to running total
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )

							_a      	=							reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase )
							return digest


if __name__ == "__main__":
				import doctest

				doctest.testmod()

