code: 
  
  
  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 : str          =    "src/diffusers"
  SCREAMING_SNAKE_CASE : Dict          =    "docs/source/en"
  SCREAMING_SNAKE_CASE : Optional[Any]          =    "."
  
  
  
  
  
  def 						_lowerCamelCase		(							SCREAMING_SNAKE_CASE_				: Optional[int]	,	SCREAMING_SNAKE_CASE_				: Any	,	SCREAMING_SNAKE_CASE_				: List[Any]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							with open(SCREAMING_SNAKE_CASE_	,	"""r"""	,	encoding="""utf-8"""	,	newline="""\n"""      ) as f:
  														a_       :   List[str]			=	f.readlines()
  							# Find the start prompt.
  							a_       :   Optional[int]			=	0
  							while not lines[start_index].startswith(SCREAMING_SNAKE_CASE_      ):
  														start_index += 1
  							start_index += 1
  
  							a_       :   Any			=	start_index
  							while not lines[end_index].startswith(SCREAMING_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 |
  SCREAMING_SNAKE_CASE : Optional[int]          =    "Model|Encoder|Decoder|ForConditionalGeneration"
  # Regexes that match TF/Flax/PT model names.
  SCREAMING_SNAKE_CASE : Any          =    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 : Dict          =    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 : List[str]          =    importlib.util.spec_from_file_location(
      "diffusers",
      os.path.join(TRANSFORMERS_PATH, "__init__.py"),
      submodule_search_locations=[TRANSFORMERS_PATH],
  )
  SCREAMING_SNAKE_CASE : Tuple          =    spec.loader.load_module()
  
  
  
  
  
  def 						_lowerCamelCase		(							SCREAMING_SNAKE_CASE_				: str      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Optional[Any]			=	re.finditer(""".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"""	,	SCREAMING_SNAKE_CASE_      )
  							return [m.group(0      ) for m in matches]
  
  
  
  
  
  def 						_lowerCamelCase		(							SCREAMING_SNAKE_CASE_				: int	,	SCREAMING_SNAKE_CASE_				: Optional[Any]      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Dict			=	2 if text == """✅""" or text == """❌""" else len(SCREAMING_SNAKE_CASE_      )
  							a_       :   Any			=	(width - text_length) // 2
  							a_       :   Any			=	width - text_length - left_indent
  							return " " * left_indent + text + " " * right_indent
  
  
  
  
  
  def 						_lowerCamelCase		(							):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Union[str, Any]			=	diffusers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
  							a_       :   Optional[int]			=	{
  							    name: config_mapping_names[code]
  							    for code, name in diffusers_module.MODEL_NAMES_MAPPING.items()
  							    if code in config_mapping_names
  							}
  							a_       :   Optional[Any]			=	{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.
  							a_       :   str			=	collections.defaultdict(SCREAMING_SNAKE_CASE_      )
  							a_       :   List[str]			=	collections.defaultdict(SCREAMING_SNAKE_CASE_      )
  							a_       :   Optional[Any]			=	collections.defaultdict(SCREAMING_SNAKE_CASE_      )
  							a_       :   Dict			=	collections.defaultdict(SCREAMING_SNAKE_CASE_      )
  							a_       :   List[str]			=	collections.defaultdict(SCREAMING_SNAKE_CASE_      )
  
  							# Let's lookup through all diffusers object (once).
  							for attr_name in dir(SCREAMING_SNAKE_CASE_      ):
  														a_       :   List[Any]			=	None
  														if attr_name.endswith("""Tokenizer"""      ):
  																					a_       :   Union[str, Any]			=	slow_tokenizers
  																					a_       :   Optional[int]			=	attr_name[:-9]
  														elif attr_name.endswith("""TokenizerFast"""      ):
  																					a_       :   Any			=	fast_tokenizers
  																					a_       :   Union[str, Any]			=	attr_name[:-13]
  														elif _re_tf_models.match(SCREAMING_SNAKE_CASE_      ) is not None:
  																					a_       :   str			=	tf_models
  																					a_       :   Dict			=	_re_tf_models.match(SCREAMING_SNAKE_CASE_      ).groups()[0]
  														elif _re_flax_models.match(SCREAMING_SNAKE_CASE_      ) is not None:
  																					a_       :   Any			=	flax_models
  																					a_       :   Optional[int]			=	_re_flax_models.match(SCREAMING_SNAKE_CASE_      ).groups()[0]
  														elif _re_pt_models.match(SCREAMING_SNAKE_CASE_      ) is not None:
  																					a_       :   Optional[int]			=	pt_models
  																					a_       :   Any			=	_re_pt_models.match(SCREAMING_SNAKE_CASE_      ).groups()[0]
  
  														if lookup_dict is not None:
  																					while len(SCREAMING_SNAKE_CASE_      ) > 0:
  																												if attr_name in model_name_to_prefix.values():
  																																			a_       :   List[str]			=	True
  																																			break
  																												# Try again after removing the last word in the name
  																												a_       :   Optional[Any]			=	"""""".join(camel_case_split(SCREAMING_SNAKE_CASE_      )[:-1]      )
  
      # Let's build that table!
  							a_       :   Union[str, Any]			=	list(model_name_to_config.keys()      )
  							model_names.sort(key=str.lower      )
  							a_       :   str			=	["""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_       :   str			=	[len(SCREAMING_SNAKE_CASE_      ) + 2 for c in columns]
  							a_       :   List[Any]			=	max([len(SCREAMING_SNAKE_CASE_      ) for name in model_names]      ) + 2
  
  							# Build the table per se
  							a_       :   Dict			=	"""|""" + """|""".join([_center_text(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      ) for c, w in zip(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )]      ) + """|\n"""
  							# Use ":-----:" format to center-aligned table cell texts
  							table += "|" + "|".join([""":""" + """-""" * (w - 2) + """:""" for w in widths]      ) + "|\n"
  
  							a_       :   Union[str, Any]			=	{True: """✅""", False: """❌"""}
  							for name in model_names:
  														a_       :   int			=	model_name_to_prefix[name]
  														a_       :   str			=	[
  														    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(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      ) for l, w in zip(SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_      )]      ) + "|\n"
  							return table
  
  
  
  
  
  def 						_lowerCamelCase		(							SCREAMING_SNAKE_CASE_				: Tuple=False      ):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  							a_       :   Dict			=	_find_text_in_file(
  							    filename=os.path.join(SCREAMING_SNAKE_CASE_	,	"""index.mdx"""      )	,	start_prompt="""<!--This table is updated automatically from the auto modules"""	,	end_prompt="""<!-- End table-->"""	,	)
  							a_       :   Optional[Any]			=	get_model_table_from_auto_modules()
  
  							if current_table != new_table:
  														if overwrite:
  																					with open(os.path.join(SCREAMING_SNAKE_CASE_	,	"""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[int]          =    argparse.ArgumentParser()
  	parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
  	SCREAMING_SNAKE_CASE : Optional[Any]          =    parser.parse_args()
  
  	check_model_table(args.fix_and_overwrite)
  
  
  
style_context: 
  
  
  from ...utils import is_transformers_available
  from .pipeline_latent_diffusion_superresolution import LDMSuperResolutionPipeline
  
  
  if is_transformers_available():
  	from .pipeline_latent_diffusion import LDMBertModel, LDMTextToImagePipeline
  
  
  