
'''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					(_lowerCamelCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE   =	42
       SCREAMING_SNAKE_CASE   =	42






class  _a					(nn.Module):





       """simple docstring"""




       SCREAMING_SNAKE_CASE   =	42
       SCREAMING_SNAKE_CASE   =	(16, 32, 96, 2_56)
       SCREAMING_SNAKE_CASE   =	jnp.floataa






       def 							UpperCamelCase					(				self   )     ->      Any:
          _SCREAMING_SNAKE_CASE  			=					nn.Conv(
              self.block_out_channels[0]							,				kernel_size=(3, 3)							,				padding=((1, 1), (1, 1))							,				dtype=self.dtype							,				)

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

          _SCREAMING_SNAKE_CASE  			=					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							,				A__   )     ->      Tuple:
          _SCREAMING_SNAKE_CASE  			=					self.conv_in(lowerCamelCase__   )
          _SCREAMING_SNAKE_CASE  			=					nn.silu(lowerCamelCase__   )

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

          _SCREAMING_SNAKE_CASE  			=					self.conv_out(lowerCamelCase__   )

          return embedding






@flax_register_to_config
class  _a					(nn.Module	,       _lowerCamelCase	,       _lowerCamelCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE   =	32
       SCREAMING_SNAKE_CASE   =	4
       SCREAMING_SNAKE_CASE   =	(
           'CrossAttnDownBlock2D',
           'CrossAttnDownBlock2D',
           'CrossAttnDownBlock2D',
           'DownBlock2D',
       )
       SCREAMING_SNAKE_CASE   =	False
       SCREAMING_SNAKE_CASE   =	(3_20, 6_40, 12_80, 12_80)
       SCREAMING_SNAKE_CASE   =	2
       SCREAMING_SNAKE_CASE   =	8
       SCREAMING_SNAKE_CASE   =	None
       SCREAMING_SNAKE_CASE   =	12_80
       SCREAMING_SNAKE_CASE   =	0.0
       SCREAMING_SNAKE_CASE   =	False
       SCREAMING_SNAKE_CASE   =	jnp.floataa
       SCREAMING_SNAKE_CASE   =	True
       SCREAMING_SNAKE_CASE   =	0
       SCREAMING_SNAKE_CASE   =	'rgb'
       SCREAMING_SNAKE_CASE   =	(16, 32, 96, 2_56)






       def 							UpperCamelCase					(				self							,				A__   )     ->      FrozenDict:
          _SCREAMING_SNAKE_CASE  			=					(1, self.in_channels, self.sample_size, self.sample_size)
          _SCREAMING_SNAKE_CASE  			=					jnp.zeros(lowerCamelCase__							,				dtype=jnp.floataa   )
          _SCREAMING_SNAKE_CASE  			=					jnp.ones((1,)							,				dtype=jnp.intaa   )
          _SCREAMING_SNAKE_CASE  			=					jnp.zeros((1, 1, self.cross_attention_dim)							,				dtype=jnp.floataa   )
          _SCREAMING_SNAKE_CASE  			=					(1, 3, self.sample_size * 8, self.sample_size * 8)
          _SCREAMING_SNAKE_CASE  			=					jnp.zeros(lowerCamelCase__							,				dtype=jnp.floataa   )

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

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






       def 							UpperCamelCase					(				self   )     ->      List[Any]:
          _SCREAMING_SNAKE_CASE  			=					self.block_out_channels
          _SCREAMING_SNAKE_CASE  			=					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.
          _SCREAMING_SNAKE_CASE  			=					self.num_attention_heads or self.attention_head_dim

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

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

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

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

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

          # down
          _SCREAMING_SNAKE_CASE  			=					[]
          _SCREAMING_SNAKE_CASE  			=					[]

          _SCREAMING_SNAKE_CASE  			=					block_out_channels[0]

          _SCREAMING_SNAKE_CASE  			=					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   ):
             _SCREAMING_SNAKE_CASE  			=					output_channel
             _SCREAMING_SNAKE_CASE  			=					block_out_channels[i]
             _SCREAMING_SNAKE_CASE  			=					i == len(lowerCamelCase__   ) - 1

             if down_block_type == "CrossAttnDownBlock2D":
                _SCREAMING_SNAKE_CASE  			=					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:
                _SCREAMING_SNAKE_CASE  			=					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   ):
                _SCREAMING_SNAKE_CASE  			=					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:
                _SCREAMING_SNAKE_CASE  			=					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__   )

          _SCREAMING_SNAKE_CASE  			=					down_blocks
          _SCREAMING_SNAKE_CASE  			=					controlnet_down_blocks

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

          _SCREAMING_SNAKE_CASE  			=					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							,				A__							,				A__							,				A__							,				A__							,				A__ = 1.0							,				A__ = True							,				A__ = False							,				)     ->      Union[FlaxControlNetOutput, Tuple]:
          _SCREAMING_SNAKE_CASE  			=					self.controlnet_conditioning_channel_order
          if channel_order == "bgr":
             _SCREAMING_SNAKE_CASE  			=					jnp.flip(lowerCamelCase__							,				axis=1   )

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

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

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

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

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

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

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

          _SCREAMING_SNAKE_CASE  			=					controlnet_down_block_res_samples

          _SCREAMING_SNAKE_CASE  			=					self.controlnet_mid_block(lowerCamelCase__   )

          # 6. scaling
          _SCREAMING_SNAKE_CASE  			=					[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__   )












from string import ascii_uppercase

__A								=       {str(ord(c) - 55): c for c in ascii_uppercase}







def      lowerCamelCase_						(			UpperCamelCase__							: int					,	UpperCamelCase__							: int )	->			str:





				"""simple docstring"""


				if isinstance(UpperCamelCase__					,	UpperCamelCase__ ):
								raise TypeError('int() can\'t convert non-string with explicit base' )
				if num < 0:
								raise ValueError('parameter must be positive int' )
				if isinstance(UpperCamelCase__					,	UpperCamelCase__ ):
								raise TypeError('\'str\' object cannot be interpreted as an integer' )
				if isinstance(UpperCamelCase__					,	UpperCamelCase__ ):
								raise TypeError('\'float\' object cannot be interpreted as an integer' )
				if base in (0, 1):
								raise ValueError('base must be >= 2' )
				if base > 36:
								raise ValueError('base must be <= 36' )
				__lowerCamelCase									=       ''
				__lowerCamelCase									=       0
				__lowerCamelCase									=       0
				while div != 1:
								__lowerCamelCase			,		__lowerCamelCase									=       divmod(UpperCamelCase__					,	UpperCamelCase__ )
								if base >= 11 and 9 < mod < 36:
												__lowerCamelCase									=       ALPHABET_VALUES[str(UpperCamelCase__ )]
								else:
												__lowerCamelCase									=       str(UpperCamelCase__ )
								new_value += actual_value
								__lowerCamelCase									=       num // base
								__lowerCamelCase									=       div
								if div == 0:
												return str(new_value[::-1] )
								elif div == 1:
												new_value += str(UpperCamelCase__ )
												return str(new_value[::-1] )

				return new_value[::-1]


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					for base in range(2, 37):
										for num in range(10_00):
															assert int(decimal_to_any(num, base), base) == num, (
															    num,
															    base,
															    decimal_to_any(num, base),
															    int(decimal_to_any(num, base), base),
															)


