


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'''
import numpy as np
from PIL import Image


def        _lowerCAmelCase					(						_UpperCamelCase						:     np.ndarray							, _UpperCamelCase						:     int							, _UpperCamelCase						:     int				)      ->			np.ndarray:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =np.array(_UpperCamelCase				)
     if arr.shape[0] != arr.shape[1]:
          raise ValueError('The input array is not a square matrix'				)
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0

     # compute the shape of the output matrix
     _SCREAMING_SNAKE_CASE							    =(arr.shape[0] - size) // stride + 1
     # initialize the output matrix with zeros of shape maxpool_shape
     _SCREAMING_SNAKE_CASE							    =np.zeros((maxpool_shape, maxpool_shape)				)

     while i < arr.shape[0]:
          if i + size > arr.shape[0]:
               # if the end of the matrix is reached, break
               break
          while j < arr.shape[1]:
               # if the end of the matrix is reached, break
               if j + size > arr.shape[1]:
                    break
               # compute the maximum of the pooling matrix
               _SCREAMING_SNAKE_CASE							    =np.max(arr[i : i + size, j : j + size]				)
               # shift the pooling matrix by stride of column pixels
               j += stride
               mat_j += 1

          # shift the pooling matrix by stride of row pixels
          i += stride
          mat_i += 1

          # reset the column index to 0
          _SCREAMING_SNAKE_CASE							    =0
          _SCREAMING_SNAKE_CASE							    =0

     return updated_arr


def        _lowerCAmelCase					(						_UpperCamelCase						:     np.ndarray							, _UpperCamelCase						:     int							, _UpperCamelCase						:     int				)      ->			np.ndarray:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =np.array(_UpperCamelCase				)
     if arr.shape[0] != arr.shape[1]:
          raise ValueError('The input array is not a square matrix'				)
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =0

     # compute the shape of the output matrix
     _SCREAMING_SNAKE_CASE							    =(arr.shape[0] - size) // stride + 1
     # initialize the output matrix with zeros of shape avgpool_shape
     _SCREAMING_SNAKE_CASE							    =np.zeros((avgpool_shape, avgpool_shape)				)

     while i < arr.shape[0]:
          # if the end of the matrix is reached, break
          if i + size > arr.shape[0]:
               break
          while j < arr.shape[1]:
               # if the end of the matrix is reached, break
               if j + size > arr.shape[1]:
                    break
               # compute the average of the pooling matrix
               _SCREAMING_SNAKE_CASE							    =int(np.average(arr[i : i + size, j : j + size]				)				)
               # shift the pooling matrix by stride of column pixels
               j += stride
               mat_j += 1

          # shift the pooling matrix by stride of row pixels
          i += stride
          mat_i += 1
          # reset the column index to 0
          _SCREAMING_SNAKE_CASE							    =0
          _SCREAMING_SNAKE_CASE							    =0

     return updated_arr


# Main Function
if __name__ == "__main__":
     from doctest import testmod

     testmod(name="avgpooling", verbose=True)

     # Loading the image
     lowerCamelCase :      Optional[Any]					 =     Image.open("path_to_image")

     # Converting the image to numpy array and maxpooling, displaying the result
     # Ensure that the image is a square matrix

     Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

     # Converting the image to numpy array and averagepooling, displaying the result
     # Ensure that the image is a square matrix

     Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()
