code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  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
  _lowerCamelCase							:		Any							=						'src/diffusers'
  _lowerCamelCase							:		Any							=						'docs/source/en'
  _lowerCamelCase							:		int							=						'.'
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		with open(lowercase_		,							"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(lowercase_						):
  				start_index += 1
  		start_index += 1
  
  		_snake_case			 = start_index
  		while not lines[end_index].startswith(lowercase_						):
  				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 |
  _lowerCamelCase							:		List[Any]							=						'Model|Encoder|Decoder|ForConditionalGeneration'
  # Regexes that match TF/Flax/PT model names.
  _lowerCamelCase							:		List[Any]							=						re.compile(R'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
  _lowerCamelCase							:		Any							=						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.
  _lowerCamelCase							:		Optional[int]							=						re.compile(R'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
  
  
  # This is to make sure the diffusers module imported is the one in the repo.
  _lowerCamelCase							:		Union[str, Any]							=						importlib.util.spec_from_file_location(
      'diffusers',
      os.path.join(TRANSFORMERS_PATH, '__init__.py'),
      submodule_search_locations=[TRANSFORMERS_PATH],
  )
  _lowerCamelCase							:		Optional[int]							=						spec.loader.load_module()
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"		,							lowercase_						)
  		return [m.group(0						) for m in matches]
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = 2 if text == "✅" or text == "❌" else len(lowercase_						)
  		_snake_case			 = (width - text_length) // 2
  		_snake_case			 = width - text_length - left_indent
  		return " " * left_indent + text + " " * right_indent
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''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(lowercase_						)
  		_snake_case			 = collections.defaultdict(lowercase_						)
  		_snake_case			 = collections.defaultdict(lowercase_						)
  		_snake_case			 = collections.defaultdict(lowercase_						)
  		_snake_case			 = collections.defaultdict(lowercase_						)
  
  		# Let's lookup through all diffusers object (once).
  		for attr_name in dir(lowercase_						):
  				_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(lowercase_						) is not None:
  						_snake_case			 = tf_models
  						_snake_case			 = _re_tf_models.match(lowercase_						).groups()[0]
  				elif _re_flax_models.match(lowercase_						) is not None:
  						_snake_case			 = flax_models
  						_snake_case			 = _re_flax_models.match(lowercase_						).groups()[0]
  				elif _re_pt_models.match(lowercase_						) is not None:
  						_snake_case			 = pt_models
  						_snake_case			 = _re_pt_models.match(lowercase_						).groups()[0]
  
  				if lookup_dict is not None:
  						while len(lowercase_						) > 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(lowercase_						)[:-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(lowercase_						) + 2 for c in columns]
  		_snake_case			 = max([len(lowercase_						) for name in model_names]						) + 2
  
  		# Build the table per se
  		_snake_case			 = "|" + "|".join([_center_text(lowercase_		,							lowercase_						) for c, w in zip(lowercase_		,							lowercase_						)]						) + "|\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(lowercase_		,							lowercase_						) for l, w in zip(lowercase_		,							lowercase_						)]						) + "|\n"
  		return table
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case ,					_snake_case ,					_snake_case ,					_snake_case			 = _find_text_in_file(
  		    filename=os.path.join(lowercase_		,							"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(lowercase_		,							"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__":
  						_lowerCamelCase							:		Dict							=						argparse.ArgumentParser()
  						parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
  						_lowerCamelCase							:		Dict							=						parser.parse_args()
  
  						check_model_table(args.fix_and_overwrite)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import importlib
  import importlib.metadata
  import os
  import warnings
  from distutils.util import strtobool
  from functools import lru_cache
  
  import torch
  from packaging import version
  from packaging.version import parse
  
  from .environment import parse_flag_from_env
  from .versions import compare_versions, is_torch_version
  
  
  try:
  						import torch_xla.core.xla_model as xm  # noqa: F401
  
  						_lowerCamelCase							:		int										=						True
  except ImportError:
  						_lowerCamelCase							:		List[str]										=						False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  _lowerCamelCase							:		List[Any]										=						torch.distributed.is_available()
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = importlib.util.find_spec(lowercase_						) is not None
  		if package_exists:
  				try:
  						_snake_case			 = importlib.metadata.metadata(lowercase_						)
  						return True
  				except importlib.metadata.PackageNotFoundError:
  						return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _torch_distributed_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		try:
  				pass
  		except ImportError:
  				print(
  				    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
  				    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
  				    " Bindings for PyTorch*."						)
  		return (
  		    importlib.util.find_spec("torch_ccl"						) is not None
  		    or importlib.util.find_spec("oneccl_bindings_for_pytorch"						) is not None
  		)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return importlib.metadata.version("oneccl_bind_pt"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformer_engine"						)
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=True						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if torch.cuda.is_available():
  				return False
  		if _tpu_available and check_device:
  				try:
  						# Will raise a RuntimeError if no XLA configuration is found
  						_snake_case			 = xm.xla_device()
  						return True
  				except RuntimeError:
  						return False
  		return _tpu_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("deepspeed"						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if is_tpu_available():
  				return not ignore_tpu
  		if torch.cuda.is_available():
  				return torch.cuda.is_bfaa_supported()
  		if is_npu_available():
  				return False
  		return True
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.39.0"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.37.2"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("bitsandbytes"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"		,							"False"						)						) == 1:
  				_snake_case			 = importlib.util.find_spec("megatron"						) is not None
  				if package_exists:
  						try:
  								_snake_case			 = parse(importlib.metadata.version("megatron-lm"						)						)
  								return compare_versions(lowercase_		,							">="		,							"2.2.0"						)
  						except Exception as e:
  								warnings.warn(f'''Parse Megatron version failed. Exception:{e}'''						)
  								return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("safetensors"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformers"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("datasets"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("aim"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("wandb"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("comet_ml"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("boto3"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if _is_package_available("rich"						):
  				if "ACCELERATE_DISABLE_RICH" in os.environ:
  						warnings.warn(
  						    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."						)
  						return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"		,							lowercase_						)
  				return parse_flag_from_env("ACCELERATE_ENABLE_RICH"		,							lowercase_						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("sagemaker"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tqdm"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("mlflow"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return is_torch_version(">="		,							"1.12"						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def get_major_and_minor_from_version(lowercase_						):
  				return str(version.parse(lowercase_						).major						) + "." + str(version.parse(lowercase_						).minor						)
  
  		_snake_case			 = importlib.metadata.version("torch"						)
  		if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
  				return False
  		_snake_case			 = "N/A"
  		try:
  				_snake_case			 = importlib.metadata.version("intel_extension_for_pytorch"						)
  		except importlib.metadata.PackageNotFoundError:
  				return False
  		_snake_case			 = get_major_and_minor_from_version(_torch_version						)
  		_snake_case			 = get_major_and_minor_from_version(_ipex_version						)
  		if torch_major_and_minor != ipex_major_and_minor:
  				warnings.warn(
  				    f'''Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,'''
  				    f''' but PyTorch {_torch_version} is found. Please switch to the matching version and run again.'''						)
  				return False
  		return True
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if importlib.util.find_spec("torch"						) is None or importlib.util.find_spec("torch_npu"						) is None:
  				return False
  
  		import torch
  		import torch_npu  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no NPU is found
  						_snake_case			 = torch.npu.device_count()
  						return torch.npu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"npu"						) and torch.npu.is_available()
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if not parse_flag_from_env("ACCELERATE_USE_XPU"		,							default=lowercase_						):
  				return False
  		if is_ipex_available():
  				import torch
  
  				if is_torch_version("<="		,							"1.12"						):
  						return False
  		else:
  				return False
  
  		import intel_extension_for_pytorch  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no XPU  is found
  						_snake_case			 = torch.xpu.device_count()
  						return torch.xpu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"xpu"						) and torch.xpu.is_available()
  
  
  
  
  
  