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



def 				a__			(					lowerCAmelCase						:							List[str]							,     lowerCAmelCase						:							Any							,     lowerCAmelCase						:							List[Any]		):






     '''simple docstring'''
     with open(lowerCAmelCase							,     "r"							,     encoding="utf-8"							,     newline="\n"		) as f:
          UpperCAmelCase__				:			List[str]							=    f.readlines()
     # Find the start prompt.
     UpperCAmelCase__				:			Union[str, Any]							=    0
     while not lines[start_index].startswith(lowerCAmelCase		):
          start_index += 1
     start_index += 1

     UpperCAmelCase__				:			List[Any]							=    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 |
A__   :						Tuple 							=     """Model|Encoder|Decoder|ForConditionalGeneration"""
# Regexes that match TF/Flax/PT model names.
A__   :						Any 							=     re.compile(R"""TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")
A__   :						Tuple 							=     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.
A__   :						List[Any] 							=     re.compile(R"""(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)""")


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



def 				a__			(					lowerCAmelCase						:							List[str]		):






     '''simple docstring'''
     UpperCAmelCase__				:			Dict							=    re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"							,     lowerCAmelCase		)
     return [m.group(0		) for m in matches]



def 				a__			(					lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Union[str, Any]		):






     '''simple docstring'''
     UpperCAmelCase__				:			List[Any]							=    2 if text == "✅" or text == "❌" else len(lowerCAmelCase		)
     UpperCAmelCase__				:			Any							=    (width - text_length) // 2
     UpperCAmelCase__				:			List[Any]							=    width - text_length - left_indent
     return " " * left_indent + text + " " * right_indent



def 				a__			(					):






     '''simple docstring'''
     UpperCAmelCase__				:			int							=    diffusers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
     UpperCAmelCase__				:			Optional[int]							=    {
         name: config_mapping_names[code]
         for code, name in diffusers_module.MODEL_NAMES_MAPPING.items()
         if code in config_mapping_names
     }
     UpperCAmelCase__				:			Optional[int]							=    {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.
     UpperCAmelCase__				:			str							=    collections.defaultdict(lowerCAmelCase		)
     UpperCAmelCase__				:			Optional[int]							=    collections.defaultdict(lowerCAmelCase		)
     UpperCAmelCase__				:			str							=    collections.defaultdict(lowerCAmelCase		)
     UpperCAmelCase__				:			str							=    collections.defaultdict(lowerCAmelCase		)
     UpperCAmelCase__				:			Union[str, Any]							=    collections.defaultdict(lowerCAmelCase		)

     # Let's lookup through all diffusers object (once).
     for attr_name in dir(lowerCAmelCase		):
          UpperCAmelCase__				:			List[str]							=    None
          if attr_name.endswith("Tokenizer"		):
               UpperCAmelCase__				:			Union[str, Any]							=    slow_tokenizers
               UpperCAmelCase__				:			Optional[Any]							=    attr_name[:-9]
          elif attr_name.endswith("TokenizerFast"		):
               UpperCAmelCase__				:			List[str]							=    fast_tokenizers
               UpperCAmelCase__				:			Union[str, Any]							=    attr_name[:-13]
          elif _re_tf_models.match(lowerCAmelCase		) is not None:
               UpperCAmelCase__				:			Union[str, Any]							=    tf_models
               UpperCAmelCase__				:			Optional[int]							=    _re_tf_models.match(lowerCAmelCase		).groups()[0]
          elif _re_flax_models.match(lowerCAmelCase		) is not None:
               UpperCAmelCase__				:			List[Any]							=    flax_models
               UpperCAmelCase__				:			Any							=    _re_flax_models.match(lowerCAmelCase		).groups()[0]
          elif _re_pt_models.match(lowerCAmelCase		) is not None:
               UpperCAmelCase__				:			str							=    pt_models
               UpperCAmelCase__				:			List[str]							=    _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():
                         UpperCAmelCase__				:			Optional[Any]							=    True
                         break
                    # Try again after removing the last word in the name
                    UpperCAmelCase__				:			Union[str, Any]							=    "".join(camel_case_split(lowerCAmelCase		)[:-1]		)

    # Let's build that table!
     UpperCAmelCase__				:			Tuple							=    list(model_name_to_config.keys()		)
     model_names.sort(key=str.lower		)
     UpperCAmelCase__				:			Dict							=    ["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).
     UpperCAmelCase__				:			List[str]							=    [len(lowerCAmelCase		) + 2 for c in columns]
     UpperCAmelCase__				:			Union[str, Any]							=    max([len(lowerCAmelCase		) for name in model_names]		) + 2

     # Build the table per se
     UpperCAmelCase__				:			str							=    "|" + "|".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"

     UpperCAmelCase__				:			List[Any]							=    {True: "✅", False: "❌"}
     for name in model_names:
          UpperCAmelCase__				:			Optional[Any]							=    model_name_to_prefix[name]
          UpperCAmelCase__				:			List[Any]							=    [
              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 				a__			(					lowerCAmelCase						:							Union[str, Any]=False		):






     '''simple docstring'''
     UpperCAmelCase__				,						UpperCAmelCase__				,						UpperCAmelCase__				,						UpperCAmelCase__				:			int							=    _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-->"							,     )
     UpperCAmelCase__				:			Optional[Any]							=    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__":
    A__   :						Union[str, Any] 							=     argparse.ArgumentParser()
    parser.add_argument("""--fix_and_overwrite""", action="""store_true""", help="""Whether to fix inconsistencies.""")
    A__   :						str 							=     parser.parse_args()

    check_model_table(args.fix_and_overwrite)





"""simple docstring"""




from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block







@dataclass
class 	_lowercase    (							lowerCAmelCase_					):


     '''simple docstring'''





     _A		    =				42







class 	_lowercase    (							lowerCAmelCase_						, lowerCAmelCase_					):


     '''simple docstring'''





     @register_to_config
     def __init__(   self			,      __UpperCamelCase = None			,      __UpperCamelCase = 3			,      __UpperCamelCase = 3			,      __UpperCamelCase = False			,      __UpperCamelCase = "positional"			,      __UpperCamelCase = 0			,      __UpperCamelCase = True			,      __UpperCamelCase = ("DownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D")			,      __UpperCamelCase = ("AttnUpBlock2D", "AttnUpBlock2D", "AttnUpBlock2D", "UpBlock2D")			,      __UpperCamelCase = (2_24, 4_48, 6_72, 8_96)			,      __UpperCamelCase = 2			,      __UpperCamelCase = 1			,      __UpperCamelCase = 1			,      __UpperCamelCase = "conv"			,      __UpperCamelCase = "conv"			,      __UpperCamelCase = "silu"			,      __UpperCamelCase = 8			,      __UpperCamelCase = 32			,      __UpperCamelCase = 1E-5			,      __UpperCamelCase = "default"			,      __UpperCamelCase = True			,      __UpperCamelCase = None			,      __UpperCamelCase = None			,      )->       Any:
          super().__init__()

          UpperCAmelCase__				:			Optional[int]							=    sample_size
          UpperCAmelCase__				:			Any							=    block_out_channels[0] * 4

          # Check inputs
          if len(__UpperCamelCase	) != len(__UpperCamelCase	):
               raise ValueError(
                   F"Must provide the same number of `down_block_types` as `up_block_types`. `down_block_types`: {down_block_types}. `up_block_types`: {up_block_types}."	)

          if len(__UpperCamelCase	) != len(__UpperCamelCase	):
               raise ValueError(
                   F"Must provide the same number of `block_out_channels` as `down_block_types`. `block_out_channels`: {block_out_channels}. `down_block_types`: {down_block_types}."	)

          # input
          UpperCAmelCase__				:			List[Any]							=    nn.Convad(__UpperCamelCase			,      block_out_channels[0]			,      kernel_size=3			,      padding=(1, 1)	)

          # time
          if time_embedding_type == "fourier":
               UpperCAmelCase__				:			int							=    GaussianFourierProjection(embedding_size=block_out_channels[0]			,      scale=16	)
               UpperCAmelCase__				:			Dict							=    2 * block_out_channels[0]
          elif time_embedding_type == "positional":
               UpperCAmelCase__				:			List[str]							=    Timesteps(block_out_channels[0]			,      __UpperCamelCase			,      __UpperCamelCase	)
               UpperCAmelCase__				:			Any							=    block_out_channels[0]

          UpperCAmelCase__				:			List[str]							=    TimestepEmbedding(__UpperCamelCase			,      __UpperCamelCase	)

          # class embedding
          if class_embed_type is None and num_class_embeds is not None:
               UpperCAmelCase__				:			Optional[Any]							=    nn.Embedding(__UpperCamelCase			,      __UpperCamelCase	)
          elif class_embed_type == "timestep":
               UpperCAmelCase__				:			str							=    TimestepEmbedding(__UpperCamelCase			,      __UpperCamelCase	)
          elif class_embed_type == "identity":
               UpperCAmelCase__				:			Union[str, Any]							=    nn.Identity(__UpperCamelCase			,      __UpperCamelCase	)
          else:
               UpperCAmelCase__				:			Optional[int]							=    None

          UpperCAmelCase__				:			str							=    nn.ModuleList([]	)
          UpperCAmelCase__				:			Any							=    None
          UpperCAmelCase__				:			Tuple							=    nn.ModuleList([]	)

          # down
          UpperCAmelCase__				:			Any							=    block_out_channels[0]
          for i, down_block_type in enumerate(__UpperCamelCase	):
               UpperCAmelCase__				:			List[Any]							=    output_channel
               UpperCAmelCase__				:			Optional[int]							=    block_out_channels[i]
               UpperCAmelCase__				:			Any							=    i == len(__UpperCamelCase	) - 1

               UpperCAmelCase__				:			List[Any]							=    get_down_block(
                   __UpperCamelCase			,      num_layers=__UpperCamelCase			,      in_channels=__UpperCamelCase			,      out_channels=__UpperCamelCase			,      temb_channels=__UpperCamelCase			,      add_downsample=not is_final_block			,      resnet_eps=__UpperCamelCase			,      resnet_act_fn=__UpperCamelCase			,      resnet_groups=__UpperCamelCase			,      attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel			,      downsample_padding=__UpperCamelCase			,      resnet_time_scale_shift=__UpperCamelCase			,      downsample_type=__UpperCamelCase			,      )
               self.down_blocks.append(__UpperCamelCase	)

          # mid
          UpperCAmelCase__				:			List[str]							=    UNetMidBlockaD(
              in_channels=block_out_channels[-1]			,      temb_channels=__UpperCamelCase			,      resnet_eps=__UpperCamelCase			,      resnet_act_fn=__UpperCamelCase			,      output_scale_factor=__UpperCamelCase			,      resnet_time_scale_shift=__UpperCamelCase			,      attention_head_dim=attention_head_dim if attention_head_dim is not None else block_out_channels[-1]			,      resnet_groups=__UpperCamelCase			,      add_attention=__UpperCamelCase			,      )

          # up
          UpperCAmelCase__				:			Tuple							=    list(reversed(__UpperCamelCase	)	)
          UpperCAmelCase__				:			Optional[Any]							=    reversed_block_out_channels[0]
          for i, up_block_type in enumerate(__UpperCamelCase	):
               UpperCAmelCase__				:			int							=    output_channel
               UpperCAmelCase__				:			List[Any]							=    reversed_block_out_channels[i]
               UpperCAmelCase__				:			Dict							=    reversed_block_out_channels[min(i + 1			,      len(__UpperCamelCase	) - 1	)]

               UpperCAmelCase__				:			int							=    i == len(__UpperCamelCase	) - 1

               UpperCAmelCase__				:			Dict							=    get_up_block(
                   __UpperCamelCase			,      num_layers=layers_per_block + 1			,      in_channels=__UpperCamelCase			,      out_channels=__UpperCamelCase			,      prev_output_channel=__UpperCamelCase			,      temb_channels=__UpperCamelCase			,      add_upsample=not is_final_block			,      resnet_eps=__UpperCamelCase			,      resnet_act_fn=__UpperCamelCase			,      resnet_groups=__UpperCamelCase			,      attention_head_dim=attention_head_dim if attention_head_dim is not None else output_channel			,      resnet_time_scale_shift=__UpperCamelCase			,      upsample_type=__UpperCamelCase			,      )
               self.up_blocks.append(__UpperCamelCase	)
               UpperCAmelCase__				:			Dict							=    output_channel

          # out
          UpperCAmelCase__				:			str							=    norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4			,      32	)
          UpperCAmelCase__				:			Tuple							=    nn.GroupNorm(num_channels=block_out_channels[0]			,      num_groups=__UpperCamelCase			,      eps=__UpperCamelCase	)
          UpperCAmelCase__				:			Any							=    nn.SiLU()
          UpperCAmelCase__				:			Optional[int]							=    nn.Convad(block_out_channels[0]			,      __UpperCamelCase			,      kernel_size=3			,      padding=1	)



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase = None			,      __UpperCamelCase = True			,      )->       Union[UNetaDOutput, Tuple]:
          # 0. center input if necessary
          if self.config.center_input_sample:
               UpperCAmelCase__				:			Any							=    2 * sample - 1.0

          # 1. time
          UpperCAmelCase__				:			Tuple							=    timestep
          if not torch.is_tensor(__UpperCamelCase	):
               UpperCAmelCase__				:			Optional[int]							=    torch.tensor([timesteps]			,      dtype=torch.long			,      device=sample.device	)
          elif torch.is_tensor(__UpperCamelCase	) and len(timesteps.shape	) == 0:
               UpperCAmelCase__				:			List[Any]							=    timesteps[None].to(sample.device	)

          # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
          UpperCAmelCase__				:			Dict							=    timesteps * torch.ones(sample.shape[0]			,      dtype=timesteps.dtype			,      device=timesteps.device	)

          UpperCAmelCase__				:			List[str]							=    self.time_proj(__UpperCamelCase	)

          # timesteps does not contain any weights and will always return f32 tensors
          # but time_embedding might actually be running in fp16. so we need to cast here.
          # there might be better ways to encapsulate this.
          UpperCAmelCase__				:			Dict							=    t_emb.to(dtype=self.dtype	)
          UpperCAmelCase__				:			Optional[int]							=    self.time_embedding(__UpperCamelCase	)

          if self.class_embedding is not None:
               if class_labels is None:
                    raise ValueError("class_labels should be provided when doing class conditioning"	)

               if self.config.class_embed_type == "timestep":
                    UpperCAmelCase__				:			List[Any]							=    self.time_proj(__UpperCamelCase	)

               UpperCAmelCase__				:			List[str]							=    self.class_embedding(__UpperCamelCase	).to(dtype=self.dtype	)
               UpperCAmelCase__				:			Optional[int]							=    emb + class_emb

          # 2. pre-process
          UpperCAmelCase__				:			List[str]							=    sample
          UpperCAmelCase__				:			str							=    self.conv_in(__UpperCamelCase	)

          # 3. down
          UpperCAmelCase__				:			List[str]							=    (sample,)
          for downsample_block in self.down_blocks:
               if hasattr(__UpperCamelCase			,      "skip_conv"	):
                    UpperCAmelCase__				,						UpperCAmelCase__				,						UpperCAmelCase__				:			Optional[Any]							=    downsample_block(
                        hidden_states=__UpperCamelCase			,      temb=__UpperCamelCase			,      skip_sample=__UpperCamelCase	)
               else:
                    UpperCAmelCase__				,						UpperCAmelCase__				:			Optional[Any]							=    downsample_block(hidden_states=__UpperCamelCase			,      temb=__UpperCamelCase	)

               down_block_res_samples += res_samples

          # 4. mid
          UpperCAmelCase__				:			Union[str, Any]							=    self.mid_block(__UpperCamelCase			,      __UpperCamelCase	)

          # 5. up
          UpperCAmelCase__				:			Dict							=    None
          for upsample_block in self.up_blocks:
               UpperCAmelCase__				:			Union[str, Any]							=    down_block_res_samples[-len(upsample_block.resnets	) :]
               UpperCAmelCase__				:			Optional[Any]							=    down_block_res_samples[: -len(upsample_block.resnets	)]

               if hasattr(__UpperCamelCase			,      "skip_conv"	):
                    UpperCAmelCase__				,						UpperCAmelCase__				:			str							=    upsample_block(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)
               else:
                    UpperCAmelCase__				:			Tuple							=    upsample_block(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)

        # 6. post-process
          UpperCAmelCase__				:			List[Any]							=    self.conv_norm_out(__UpperCamelCase	)
          UpperCAmelCase__				:			Any							=    self.conv_act(__UpperCamelCase	)
          UpperCAmelCase__				:			Optional[Any]							=    self.conv_out(__UpperCamelCase	)

          if skip_sample is not None:
               sample += skip_sample

          if self.config.time_embedding_type == "fourier":
               UpperCAmelCase__				:			str							=    timesteps.reshape((sample.shape[0], *([1] * len(sample.shape[1:]	)))	)
               UpperCAmelCase__				:			int							=    sample / timesteps

          if not return_dict:
               return (sample,)

          return UNetaDOutput(sample=__UpperCamelCase	)



