


import argparse
import collections
import importlib.util
import os
import re


# 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
SCREAMING_SNAKE_CASE		:Any											=       """src/diffusers"""
SCREAMING_SNAKE_CASE		:Any											=       """docs/source/en"""
SCREAMING_SNAKE_CASE		:List[Any]											=       """."""



def      _lowerCAmelCase  (							lowerCAmelCase_							:int						,  lowerCAmelCase_							:List[Any]						,  lowerCAmelCase_							:Optional[Any]							)->Optional[Any]:
    '''simple docstring'''






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

    snake_case_         =   start_index
    while not lines[end_index].startswith(lowerCAmelCase_							):
        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 |
SCREAMING_SNAKE_CASE		:str											=       """Model|Encoder|Decoder|ForConditionalGeneration"""
# Regexes that match TF/Flax/PT model names.
SCREAMING_SNAKE_CASE		:Tuple											=       re.compile(R'''TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')
SCREAMING_SNAKE_CASE		:Dict											=       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.
SCREAMING_SNAKE_CASE		:int											=       re.compile(R'''(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')


# This is to make sure the diffusers module imported is the one in the repo.
SCREAMING_SNAKE_CASE		:Dict											=       importlib.util.spec_from_file_location(
    '''diffusers''',
    os.path.join(TRANSFORMERS_PATH, '''__init__.py'''),
    submodule_search_locations=[TRANSFORMERS_PATH],
)
SCREAMING_SNAKE_CASE		:Union[str, Any]											=       spec.loader.load_module()



def      _lowerCAmelCase  (							lowerCAmelCase_							:Tuple							)->Tuple:
    '''simple docstring'''






    snake_case_         =   re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"						,  lowerCAmelCase_							)
    return [m.group(0							) for m in matches]



def      _lowerCAmelCase  (							lowerCAmelCase_							:Optional[int]						,  lowerCAmelCase_							:Optional[Any]							)->int:
    '''simple docstring'''






    snake_case_         =   2 if text == "✅" or text == "❌" else len(lowerCAmelCase_							)
    snake_case_         =   (width - text_length) // 2
    snake_case_         =   width - text_length - left_indent
    return " " * left_indent + text + " " * right_indent



def      _lowerCAmelCase  (							)->Tuple:
    '''simple docstring'''






    snake_case_         =   diffusers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
    snake_case_         =   {
        name: config_mapping_names[code]
        for code, name in diffusers_module.MODEL_NAMES_MAPPING.items()
        if code in config_mapping_names
    }
    snake_case_         =   {name: config.replace("ConfigMixin"						,  ""							) 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.
    snake_case_         =   collections.defaultdict(lowerCAmelCase_							)
    snake_case_         =   collections.defaultdict(lowerCAmelCase_							)
    snake_case_         =   collections.defaultdict(lowerCAmelCase_							)
    snake_case_         =   collections.defaultdict(lowerCAmelCase_							)
    snake_case_         =   collections.defaultdict(lowerCAmelCase_							)

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

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

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

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

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



def      _lowerCAmelCase  (							lowerCAmelCase_							:Union[str, Any]=False							)->str:
    '''simple docstring'''






    snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_         =   _find_text_in_file(
        filename=os.path.join(lowerCAmelCase_						,  "index.mdx"							)						,  start_prompt="<!--This table is updated automatically from the auto modules"						,  end_prompt="<!-- End table-->"						,  )
    snake_case_         =   get_model_table_from_auto_modules()

    if current_table != new_table:
        if overwrite:
            with open(os.path.join(lowerCAmelCase_						,  "index.mdx"							)						,  "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.mdx` has not been updated. Run `make fix-copies` to fix this."							)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE		:Optional[Any]											=       argparse.ArgumentParser()
   parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
   SCREAMING_SNAKE_CASE		:int											=       parser.parse_args()

   check_model_table(args.fix_and_overwrite)








import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


SCREAMING_SNAKE_CASE		:Tuple											=       logging.get_logger(__name__)


class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    Any					)				->	List[str]:




     """simple docstring"""
     super().__init__()
     if version.parse(torch.__version__					) < version.parse("1.12.0"					):
        raise ImportError(
            F'''You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use '''
            "PytorchGELUTanh. Please upgrade torch."					)



  def    lowerCAmelCase__					(       self    :    Optional[int]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return nn.functional.gelu(_lowerCAmelCase      ,			approximate="tanh"					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    int      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi					) * (input + 0.044_715 * torch.pow(_lowerCAmelCase      ,			3.0					))					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    int      ,			_lowerCAmelCase    :    bool = False					)				->	int:




     """simple docstring"""
     super().__init__()
     if use_gelu_python:
        snake_case_         =   self._gelu_python
     else:
        snake_case_         =   nn.functional.gelu



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0					)					))



  def    lowerCAmelCase__					(       self    :    Dict      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return self.act(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    Optional[int]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return 0.5 * input * (1.0 + torch.tanh(input * 0.7_978_845_608 * (1.0 + 0.044_715 * input * input)					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    int      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input * torch.sigmoid(1.702 * input					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    List[str]      ,			_lowerCAmelCase    :    float      ,			_lowerCAmelCase    :    float					)				->	Any:




     """simple docstring"""
     if min > max:
        raise ValueError(F'''min should be < max (got min: {min}, max: {max})'''					)

     super().__init__()
     snake_case_         =   min
     snake_case_         =   max



  def    lowerCAmelCase__					(       self    :    Union[str, Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return torch.clip(gelu(_lowerCAmelCase					)      ,			self.min      ,			self.max					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    Any					)				->	str:




     """simple docstring"""
     super().__init__()
     snake_case_         =   math.sqrt(2 / math.pi					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.044_715 * torch.pow(_lowerCAmelCase      ,			3					))					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    str      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return nn.functional.silu(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    Optional[int]					)				->	List[Any]:




     """simple docstring"""
     super().__init__()
     if version.parse(torch.__version__					) < version.parse("1.9.0"					):
        snake_case_         =   self._mish_python
     else:
        snake_case_         =   nn.functional.mish



  def    lowerCAmelCase__					(       self    :    Tuple      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input * torch.tanh(nn.functional.softplus(_lowerCAmelCase					)					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return self.act(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    List[str]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    List[Any]      ,			_lowerCAmelCase    :    List[Any]      ,			_lowerCAmelCase    :    Union[str, Any]=0.707_107      ,			_lowerCAmelCase    :    int=0.282_095					)				->	List[str]:




     """simple docstring"""
     snake_case_         =   (input - mu).div(sigma * math.sqrt(2.0					)					)
     return 0.5 * (1.0 + torch.erf(_lowerCAmelCase					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    Any      ,			_lowerCAmelCase    :    Union[str, Any]					)				->	Any:




     """simple docstring"""
     snake_case_         =   nn.functional.relu(_lowerCAmelCase					)
     snake_case_         =   torch.square(_lowerCAmelCase					)
     return squared






class       __lowerCAmelCase       (	a   ):






  """simple docstring"""





  def __getitem__(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    str					)				->	Optional[int]:




     """simple docstring"""
     snake_case_         =   super().__getitem__(_lowerCAmelCase					)
     snake_case_      ,      snake_case_         =   content if isinstance(_lowerCAmelCase      ,			_lowerCAmelCase					) else (content, {})
     return cls(**_lowerCAmelCase					)






SCREAMING_SNAKE_CASE		:Optional[int]											=       {
    '''gelu''': GELUActivation,
    '''gelu_10''': (ClippedGELUActivation, {'''min''': -10, '''max''': 10}),
    '''gelu_fast''': FastGELUActivation,
    '''gelu_new''': NewGELUActivation,
    '''gelu_python''': (GELUActivation, {'''use_gelu_python''': True}),
    '''gelu_pytorch_tanh''': PytorchGELUTanh,
    '''gelu_accurate''': AccurateGELUActivation,
    '''laplace''': LaplaceActivation,
    '''linear''': LinearActivation,
    '''mish''': MishActivation,
    '''quick_gelu''': QuickGELUActivation,
    '''relu''': nn.ReLU,
    '''relu2''': ReLUSquaredActivation,
    '''relu6''': nn.ReLUa,
    '''sigmoid''': nn.Sigmoid,
    '''silu''': SiLUActivation,
    '''swish''': SiLUActivation,
    '''tanh''': nn.Tanh,
}
SCREAMING_SNAKE_CASE		:Optional[int]											=       ClassInstantier(ACTaCLS)



def      _lowerCAmelCase  (							lowerCAmelCase_							:Optional[Any]							)->Union[str, Any]:
   '''simple docstring'''






   if activation_string in ACTaFN:
      return ACTaFN[activation_string]
   else:
      raise KeyError(F'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()							)}'''							)


# For backwards compatibility with: from activations import gelu_python
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''gelu_python''')
SCREAMING_SNAKE_CASE		:int											=       get_activation('''gelu_new''')
SCREAMING_SNAKE_CASE		:List[Any]											=       get_activation('''gelu''')
SCREAMING_SNAKE_CASE		:int											=       get_activation('''gelu_fast''')
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''quick_gelu''')
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''silu''')
SCREAMING_SNAKE_CASE		:Any											=       get_activation('''mish''')



SCREAMING_SNAKE_CASE		:Optional[Any]											=       get_activation('''linear''')




