

"""simple docstring"""



from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)



@flax.struct.dataclass
class 					a						(       UpperCAmelCase__				):



    """simple docstring"""



    UpperCAmelCase						 =					42
    UpperCAmelCase						 =					42



class 					a						(       nn.Module				):



    """simple docstring"""



    UpperCAmelCase						 =					42
    UpperCAmelCase						 =					(1_6, 3_2, 9_6, 2_5_6)
    UpperCAmelCase						 =					jnp.floataa

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  nn.Conv(
             self.block_out_channels[0]    ,						kernel_size=(3, 3)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)

         A__										=  []
         for i in range(len(self.block_out_channels       ) - 1       ):
              A__										=  self.block_out_channels[i]
              A__										=  self.block_out_channels[i + 1]
              A__										=  nn.Conv(
                  lowerCamelCase__    ,						kernel_size=(3, 3)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)
              blocks.append(lowerCamelCase__       )
              A__										=  nn.Conv(
                  lowerCamelCase__    ,						kernel_size=(3, 3)    ,						strides=(2, 2)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)
              blocks.append(lowerCamelCase__       )
         A__										=  blocks

         A__										=  nn.Conv(
             self.conditioning_embedding_channels    ,						kernel_size=(3, 3)    ,						padding=((1, 1), (1, 1))    ,						kernel_init=nn.initializers.zeros_init()    ,						bias_init=nn.initializers.zeros_init()    ,						dtype=self.dtype    ,						)





    def __call__(     self: Optional[Any]    ,						UpperCamelCase: Tuple       ):






         """simple docstring"""


         A__										=  self.conv_in(lowerCamelCase__       )
         A__										=  nn.silu(lowerCamelCase__       )

         for block in self.blocks:
              A__										=  block(lowerCamelCase__       )
              A__										=  nn.silu(lowerCamelCase__       )

         A__										=  self.conv_out(lowerCamelCase__       )

         return embedding



@flax_register_to_config
class 					a						(       nn.Module,	UpperCAmelCase__,	UpperCAmelCase__				):



    """simple docstring"""



    UpperCAmelCase						 =					3_2
    UpperCAmelCase						 =					4
    UpperCAmelCase						 =					(
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					(3_2_0, 6_4_0, 1_2_8_0, 1_2_8_0)
    UpperCAmelCase						 =					2
    UpperCAmelCase						 =					8
    UpperCAmelCase						 =					None
    UpperCAmelCase						 =					1_2_8_0
    UpperCAmelCase						 =					0.0
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					jnp.floataa
    UpperCAmelCase						 =					True
    UpperCAmelCase						 =					0
    UpperCAmelCase						 =					"rgb"
    UpperCAmelCase						 =					(1_6, 3_2, 9_6, 2_5_6)

    def 				UpperCamelCase	(     self: Tuple    ,						UpperCamelCase: jax.random.KeyArray       ):






         """simple docstring"""


         A__										=  (1, self.in_channels, self.sample_size, self.sample_size)
         A__										=  jnp.zeros(lowerCamelCase__    ,						dtype=jnp.floataa       )
         A__										=  jnp.ones((1,)    ,						dtype=jnp.intaa       )
         A__										=  jnp.zeros((1, 1, self.cross_attention_dim)    ,						dtype=jnp.floataa       )
         A__										=  (1, 3, self.sample_size * 8, self.sample_size * 8)
         A__										=  jnp.zeros(lowerCamelCase__    ,						dtype=jnp.floataa       )

         A__										=  jax.random.split(lowerCamelCase__       )
         A__										=  {"params": params_rng, "dropout": dropout_rng}

         return self.init(lowerCamelCase__    ,						lowerCamelCase__    ,						lowerCamelCase__    ,						lowerCamelCase__    ,						lowerCamelCase__       )["params"]

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__										=  self.block_out_channels
         A__										=  block_out_channels[0] * 4

         # If `num_attention_heads` is not defined (which is the case for most models)
         # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
         # The reason for this behavior is to correct for incorrectly named variables that were introduced
         # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
         # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
         # which is why we correct for the naming here.
         A__										=  self.num_attention_heads or self.attention_head_dim

         # input
         A__										=  nn.Conv(
             block_out_channels[0]    ,						kernel_size=(3, 3)    ,						strides=(1, 1)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)

         # time
         A__										=  FlaxTimesteps(
             block_out_channels[0]    ,						flip_sin_to_cos=self.flip_sin_to_cos    ,						freq_shift=self.config.freq_shift       )
         A__										=  FlaxTimestepEmbedding(lowerCamelCase__    ,						dtype=self.dtype       )

         A__										=  FlaxControlNetConditioningEmbedding(
             conditioning_embedding_channels=block_out_channels[0]    ,						block_out_channels=self.conditioning_embedding_out_channels    ,						)

         A__										=  self.only_cross_attention
         if isinstance(lowerCamelCase__    ,						lowerCamelCase__       ):
              A__										=  (only_cross_attention,) * len(self.down_block_types       )

         if isinstance(lowerCamelCase__    ,						lowerCamelCase__       ):
              A__										=  (num_attention_heads,) * len(self.down_block_types       )

         # down
         A__										=  []
         A__										=  []

         A__										=  block_out_channels[0]

         A__										=  nn.Conv(
             lowerCamelCase__    ,						kernel_size=(1, 1)    ,						padding="""VALID"""    ,						kernel_init=nn.initializers.zeros_init()    ,						bias_init=nn.initializers.zeros_init()    ,						dtype=self.dtype    ,						)
         controlnet_down_blocks.append(lowerCamelCase__       )

         for i, down_block_type in enumerate(self.down_block_types       ):
              A__										=  output_channel
              A__										=  block_out_channels[i]
              A__										=  i == len(lowerCamelCase__       ) - 1

              if down_block_type == "CrossAttnDownBlock2D":
                   A__										=  FlaxCrossAttnDownBlockaD(
                       in_channels=lowerCamelCase__    ,						out_channels=lowerCamelCase__    ,						dropout=self.dropout    ,						num_layers=self.layers_per_block    ,						num_attention_heads=num_attention_heads[i]    ,						add_downsample=not is_final_block    ,						use_linear_projection=self.use_linear_projection    ,						only_cross_attention=only_cross_attention[i]    ,						dtype=self.dtype    ,						)
              else:
                   A__										=  FlaxDownBlockaD(
                       in_channels=lowerCamelCase__    ,						out_channels=lowerCamelCase__    ,						dropout=self.dropout    ,						num_layers=self.layers_per_block    ,						add_downsample=not is_final_block    ,						dtype=self.dtype    ,						)

              down_blocks.append(lowerCamelCase__       )

              for _ in range(self.layers_per_block       ):
                   A__										=  nn.Conv(
                       lowerCamelCase__    ,						kernel_size=(1, 1)    ,						padding="""VALID"""    ,						kernel_init=nn.initializers.zeros_init()    ,						bias_init=nn.initializers.zeros_init()    ,						dtype=self.dtype    ,						)
                   controlnet_down_blocks.append(lowerCamelCase__       )

              if not is_final_block:
                   A__										=  nn.Conv(
                       lowerCamelCase__    ,						kernel_size=(1, 1)    ,						padding="""VALID"""    ,						kernel_init=nn.initializers.zeros_init()    ,						bias_init=nn.initializers.zeros_init()    ,						dtype=self.dtype    ,						)
                   controlnet_down_blocks.append(lowerCamelCase__       )

         A__										=  down_blocks
         A__										=  controlnet_down_blocks

         # mid
         A__										=  block_out_channels[-1]
         A__										=  FlaxUNetMidBlockaDCrossAttn(
             in_channels=lowerCamelCase__    ,						dropout=self.dropout    ,						num_attention_heads=num_attention_heads[-1]    ,						use_linear_projection=self.use_linear_projection    ,						dtype=self.dtype    ,						)

         A__										=  nn.Conv(
             lowerCamelCase__    ,						kernel_size=(1, 1)    ,						padding="""VALID"""    ,						kernel_init=nn.initializers.zeros_init()    ,						bias_init=nn.initializers.zeros_init()    ,						dtype=self.dtype    ,						)





    def __call__(     self: Union[str, Any]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: int    ,						UpperCamelCase: float = 1.0    ,						UpperCamelCase: bool = True    ,						UpperCamelCase: bool = False    ,						):






         """simple docstring"""


         A__										=  self.controlnet_conditioning_channel_order
         if channel_order == "bgr":
              A__										=  jnp.flip(lowerCamelCase__    ,						axis=1       )

         # 1. time
         if not isinstance(lowerCamelCase__    ,						jnp.ndarray       ):
              A__										=  jnp.array([timesteps]    ,						dtype=jnp.intaa       )
         elif isinstance(lowerCamelCase__    ,						jnp.ndarray       ) and len(timesteps.shape       ) == 0:
              A__										=  timesteps.astype(dtype=jnp.floataa       )
              A__										=  jnp.expand_dims(lowerCamelCase__    ,						0       )

         A__										=  self.time_proj(lowerCamelCase__       )
         A__										=  self.time_embedding(lowerCamelCase__       )

         # 2. pre-process
         A__										=  jnp.transpose(lowerCamelCase__    ,						(0, 2, 3, 1)       )
         A__										=  self.conv_in(lowerCamelCase__       )

         A__										=  jnp.transpose(lowerCamelCase__    ,						(0, 2, 3, 1)       )
         A__										=  self.controlnet_cond_embedding(lowerCamelCase__       )
         sample += controlnet_cond

         # 3. down
         A__										=  (sample,)
         for down_block in self.down_blocks:
              if isinstance(lowerCamelCase__    ,						lowerCamelCase__       ):
                   A__										=  down_block(lowerCamelCase__    ,						lowerCamelCase__    ,						lowerCamelCase__    ,						deterministic=not train       )
              else:
                   A__										=  down_block(lowerCamelCase__    ,						lowerCamelCase__    ,						deterministic=not train       )
              down_block_res_samples += res_samples

         # 4. mid
         A__										=  self.mid_block(lowerCamelCase__    ,						lowerCamelCase__    ,						lowerCamelCase__    ,						deterministic=not train       )

         # 5. contronet blocks
         A__										=  ()
         for down_block_res_sample, controlnet_block in zip(lowerCamelCase__    ,						self.controlnet_down_blocks       ):
              A__										=  controlnet_block(lowerCamelCase__       )
              controlnet_down_block_res_samples += (down_block_res_sample,)

         A__										=  controlnet_down_block_res_samples

         A__										=  self.controlnet_mid_block(lowerCamelCase__       )

         # 6. scaling
         A__										=  [sample * conditioning_scale for sample in down_block_res_samples]
         mid_block_res_sample *= conditioning_scale

         if not return_dict:
              return (down_block_res_samples, mid_block_res_sample)

         return FlaxControlNetOutput(
             down_block_res_samples=lowerCamelCase__    ,						mid_block_res_sample=lowerCamelCase__       )









"""simple docstring"""



from itertools import count





def  _snake_case     (    UpperCAmelCase_  :					int = 50			):
     A__										=  [1] * min_block_length

     for n in count(UpperCAmelCase_			):
          fill_count_functions.append(1			)

          for block_length in range(UpperCAmelCase_					,   n + 1			):
               for block_start in range(n - block_length			):
                    fill_count_functions[n] += fill_count_functions[
                        n - block_start - block_length - 1
                    ]

               fill_count_functions[n] += 1

          if fill_count_functions[n] > 100_0000:
               break

     return n


if __name__ == "__main__":
 print(f"""{solution() = }""")






