
import unittest

from transformers import BertGenerationConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import BertGenerationDecoder, BertGenerationEncoder






class   UpperCAmelCase		:



   def __init__(self		:					Tuple    ,						snake_case__		:					int    ,						snake_case__		:					Optional[int]=13    ,						snake_case__		:					List[Any]=7    ,						snake_case__		:					Tuple=True    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					Union[str, Any]=99    ,						snake_case__		:					Any=32    ,						snake_case__		:					Optional[Any]=5    ,						snake_case__		:					Any=4    ,						snake_case__		:					str=37    ,						snake_case__		:					Optional[int]="gelu"    ,						snake_case__		:					List[Any]=0.1    ,						snake_case__		:					List[str]=0.1    ,						snake_case__		:					int=50    ,						snake_case__		:					List[Any]=0.02    ,						snake_case__		:					Any=True    ,						snake_case__		:					List[Any]=None    ,						)		->	Tuple:


          '''simple docstring'''


          snake_case       :   Optional[Any]							=      parent
          snake_case       :   Optional[int]							=      batch_size
          snake_case       :   Optional[int]							=      seq_length
          snake_case       :   List[Any]							=      is_training
          snake_case       :   List[Any]							=      use_input_mask
          snake_case       :   Optional[int]							=      vocab_size
          snake_case       :   Optional[int]							=      hidden_size
          snake_case       :   List[Any]							=      num_hidden_layers
          snake_case       :   List[str]							=      num_attention_heads
          snake_case       :   Optional[Any]							=      intermediate_size
          snake_case       :   Optional[Any]							=      hidden_act
          snake_case       :   str							=      hidden_dropout_prob
          snake_case       :   Optional[Any]							=      attention_probs_dropout_prob
          snake_case       :   Union[str, Any]							=      max_position_embeddings
          snake_case       :   List[str]							=      initializer_range
          snake_case       :   Optional[Any]							=      use_labels
          snake_case       :   Dict							=      scope



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	List[Any]:


          '''simple docstring'''


          snake_case       :   Tuple							=      ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size )

          snake_case       :   List[Any]							=      None
          if self.use_input_mask:
                 snake_case       :   int							=      random_attention_mask([self.batch_size, self.seq_length] )

          if self.use_labels:
                 snake_case       :   str							=      ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size )

          snake_case       :   Optional[Any]							=      self.get_config()

          return config, input_ids, input_mask, token_labels



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	int:


          '''simple docstring'''


          return BertGenerationConfig(
              vocab_size=self.vocab_size    ,						hidden_size=self.hidden_size    ,						num_hidden_layers=self.num_hidden_layers    ,						num_attention_heads=self.num_attention_heads    ,						intermediate_size=self.intermediate_size    ,						hidden_act=self.hidden_act    ,						hidden_dropout_prob=self.hidden_dropout_prob    ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,						max_position_embeddings=self.max_position_embeddings    ,						is_decoder=snake_case__    ,						initializer_range=self.initializer_range    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          (
              (
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					
          )       :   Tuple							=      self.prepare_config_and_inputs()

          snake_case       :   Any							=      True
          snake_case       :   List[str]							=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
          snake_case       :   Optional[int]							=      ids_tensor([self.batch_size, self.seq_length]    ,						vocab_size=2 )

          return (
              config,
              input_ids,
              input_mask,
              token_labels,
              encoder_hidden_states,
              encoder_attention_mask,
          )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any]    ,						snake_case__		:					str    ,						snake_case__		:					str    ,						snake_case__		:					Tuple    ,						snake_case__		:					int    ,						**snake_case__		:					int    ,						)		->	str:


          '''simple docstring'''


          snake_case       :   int							=      BertGenerationEncoder(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   str							=      model(snake_case__    ,						attention_mask=snake_case__ )
          snake_case       :   List[Any]							=      model(snake_case__ )
          self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int    ,						snake_case__		:					Tuple    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					str    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					int    ,						**snake_case__		:					Optional[Any]    ,						)		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   str							=      True
          snake_case       :   int							=      BertGenerationEncoder(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   Dict							=      model(
              snake_case__    ,						attention_mask=snake_case__    ,						encoder_hidden_states=snake_case__    ,						encoder_attention_mask=snake_case__    ,						)
          snake_case       :   Optional[Any]							=      model(
              snake_case__    ,						attention_mask=snake_case__    ,						encoder_hidden_states=snake_case__    ,						)
          self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Any    ,						snake_case__		:					Dict    ,						snake_case__		:					Any    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					str    ,						**snake_case__		:					str    ,						)		->	Dict:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      True
          snake_case       :   Union[str, Any]							=      True
          snake_case       :   Optional[int]							=      BertGenerationDecoder(config=snake_case__ ).to(snake_case__ ).eval()

          # first forward pass
          snake_case       :   Optional[Any]							=      model(
              snake_case__    ,						attention_mask=snake_case__    ,						encoder_hidden_states=snake_case__    ,						encoder_attention_mask=snake_case__    ,						use_cache=snake_case__    ,						)
          snake_case       :   Any							=      outputs.past_key_values

          # create hypothetical multiple next token and extent to next_input_ids
          snake_case       :   Any							=      ids_tensor((self.batch_size, 3)    ,						config.vocab_size )
          snake_case       :   Optional[Any]							=      ids_tensor((self.batch_size, 3)    ,						vocab_size=2 )

          # append to next input_ids and
          snake_case       :   List[Any]							=      torch.cat([input_ids, next_tokens]    ,						dim=-1 )
          snake_case       :   Optional[Any]							=      torch.cat([input_mask, next_mask]    ,						dim=-1 )

          snake_case       :   Tuple							=      model(
              snake_case__    ,						attention_mask=snake_case__    ,						encoder_hidden_states=snake_case__    ,						encoder_attention_mask=snake_case__    ,						output_hidden_states=snake_case__    ,						)["hidden_states"][0]
          snake_case       :   Dict							=      model(
              snake_case__    ,						attention_mask=snake_case__    ,						encoder_hidden_states=snake_case__    ,						encoder_attention_mask=snake_case__    ,						past_key_values=snake_case__    ,						output_hidden_states=snake_case__    ,						)["hidden_states"][0]

          # select random slice
          snake_case       :   Tuple							=      ids_tensor((1,)    ,						output_from_past.shape[-1] ).item()
          snake_case       :   Optional[Any]							=      output_from_no_past[:, -3:, random_slice_idx].detach()
          snake_case       :   Optional[Any]							=      output_from_past[:, :, random_slice_idx].detach()

          self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] )

          # test that outputs are equal for slice
          self.parent.assertTrue(torch.allclose(snake_case__    ,						snake_case__    ,						atol=1e-3 ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						snake_case__		:					Tuple    ,						snake_case__		:					Dict    ,						snake_case__		:					Tuple    ,						snake_case__		:					Optional[Any]    ,						*snake_case__		:					List[Any]    ,						)		->	str:


          '''simple docstring'''


          snake_case       :   str							=      BertGenerationDecoder(snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   Optional[Any]							=      model(snake_case__    ,						attention_mask=snake_case__    ,						labels=snake_case__ )
          self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.vocab_size) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Optional[int]:


          '''simple docstring'''


          snake_case				,					snake_case				,					snake_case				,					snake_case       :   List[Any]							=      self.prepare_config_and_inputs()
          snake_case       :   Dict							=      {"input_ids": input_ids, "attention_mask": input_mask}
          return config, inputs_dict






@require_torch
class   UpperCAmelCase		(						A_       ,A_       ,A_       ,unittest.TestCase ):
   A__					:		str						     =     (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
   A__					:		Any						     =     (BertGenerationDecoder,) if is_torch_available() else ()
   A__					:		str						     =     (
       {"feature-extraction": BertGenerationEncoder, "text-generation": BertGenerationDecoder}
       if is_torch_available()
       else {}
   )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Any:


          '''simple docstring'''


          snake_case       :   Dict							=      BertGenerationEncoderTester(self )
          snake_case       :   List[Any]							=      ConfigTester(self    ,						config_class=snake_case__    ,						hidden_size=37 )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	List[Any]:


          '''simple docstring'''


          self.config_tester.run_common_tests()



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Any:


          '''simple docstring'''


          snake_case       :   Tuple							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	int:


          '''simple docstring'''


          snake_case				,					snake_case				,					snake_case				,					snake_case       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs()
          snake_case       :   List[Any]							=      "bert"
          self.model_tester.create_and_check_model(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Union[str, Any] )		->	int:


          '''simple docstring'''


          snake_case       :   List[str]							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_model_as_decoder(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Dict:


          '''simple docstring'''


          snake_case       :   Tuple							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_decoder_model_past_large_inputs(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Any:


          '''simple docstring'''


          (
              (
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					
          )       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs_for_decoder()

          snake_case       :   Dict							=      None

          self.model_tester.create_and_check_model_as_decoder(
              snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	int:


          '''simple docstring'''


          snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_for_causal_lm(*snake_case__ )



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Tuple:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          self.assertIsNotNone(snake_case__ )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Any:


          '''simple docstring'''


          snake_case       :   Tuple							=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          snake_case       :   Dict							=      torch.tensor([[1_01, 75_92, 10_10, 20_26, 38_99, 20_03, 1_01_40, 1_02]] )
          with torch.no_grad():
                 snake_case       :   List[str]							=      model(snake_case__ )[0]
          snake_case       :   List[str]							=      torch.Size([1, 8, 10_24] )
          self.assertEqual(output.shape    ,						snake_case__ )
          snake_case       :   int							=      torch.tensor(
              [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]] )
          self.assertTrue(torch.allclose(output[:, :3, :3]    ,						snake_case__    ,						atol=1e-4 ) )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Tuple:


          '''simple docstring'''


          snake_case       :   List[Any]							=      BertGenerationDecoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          snake_case       :   List[str]							=      torch.tensor([[1_01, 75_92, 10_10, 20_26, 38_99, 20_03, 1_01_40, 1_02]] )
          with torch.no_grad():
                 snake_case       :   List[Any]							=      model(snake_case__ )[0]
          snake_case       :   List[Any]							=      torch.Size([1, 8, 5_03_58] )
          self.assertEqual(output.shape    ,						snake_case__ )
          snake_case       :   Union[str, Any]							=      torch.tensor(
              [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]] )
          self.assertTrue(torch.allclose(output[:, :3, :3]    ,						snake_case__    ,						atol=1e-4 ) )







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,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)






@flax.struct.dataclass
class   UpperCAmelCase		(						A_ ):
   A__					:		jnp.ndarray






@flax_register_to_config
class   UpperCAmelCase		(						nn.Module       ,A_       ,A_ ):
   A__					:		int						     =     32
   A__					:		int						     =     4
   A__					:		int						     =     4
   A__					:		Tuple[str]						     =     (
       "CrossAttnDownBlock2D",
       "CrossAttnDownBlock2D",
       "CrossAttnDownBlock2D",
       "DownBlock2D",
   )
   A__					:		Tuple[str]						     =     ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
   A__					:		Union[bool, Tuple[bool]]						     =     False
   A__					:		Tuple[int]						     =     (3_20, 6_40, 12_80, 12_80)
   A__					:		int						     =     2
   A__					:		Union[int, Tuple[int]]						     =     8
   A__					:		Optional[Union[int, Tuple[int]]]						     =     None
   A__					:		int						     =     12_80
   A__					:		float						     =     0.0
   A__					:		bool						     =     False
   A__					:		jnp.dtype						     =     jnp.floataa
   A__					:		bool						     =     True
   A__					:		int						     =     0
   A__					:		bool						     =     False



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					jax.random.KeyArray )		->	FrozenDict:


          '''simple docstring'''


          snake_case       :   Dict							=      (1, self.in_channels, self.sample_size, self.sample_size)
          snake_case       :   Any							=      jnp.zeros(snake_case__    ,						dtype=jnp.floataa )
          snake_case       :   List[str]							=      jnp.ones((1,)    ,						dtype=jnp.intaa )
          snake_case       :   str							=      jnp.zeros((1, 1, self.cross_attention_dim)    ,						dtype=jnp.floataa )

          snake_case				,					snake_case       :   Optional[int]							=      jax.random.split(snake_case__ )
          snake_case       :   Union[str, Any]							=      {"params": params_rng, "dropout": dropout_rng}

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



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Tuple:


          '''simple docstring'''


          snake_case       :   str							=      self.block_out_channels
          snake_case       :   Optional[Any]							=      block_out_channels[0] * 4

          if self.num_attention_heads is not None:
                 raise ValueError(
                     "At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19." )

          # 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.
          snake_case       :   Tuple							=      self.num_attention_heads or self.attention_head_dim

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

          # time
          snake_case       :   Union[str, Any]							=      FlaxTimesteps(
              block_out_channels[0]    ,						flip_sin_to_cos=self.flip_sin_to_cos    ,						freq_shift=self.config.freq_shift )
          snake_case       :   Dict							=      FlaxTimestepEmbedding(snake_case__    ,						dtype=self.dtype )

          snake_case       :   List[str]							=      self.only_cross_attention
          if isinstance(snake_case__    ,						snake_case__ ):
                 snake_case       :   List[Any]							=      (only_cross_attention,) * len(self.down_block_types )

          if isinstance(snake_case__    ,						snake_case__ ):
                 snake_case       :   List[Any]							=      (num_attention_heads,) * len(self.down_block_types )

          # down
          snake_case       :   List[Any]							=      []
          snake_case       :   Optional[int]							=      block_out_channels[0]
          for i, down_block_type in enumerate(self.down_block_types ):
                 snake_case       :   List[Any]							=      output_channel
                 snake_case       :   Dict							=      block_out_channels[i]
                 snake_case       :   Optional[Any]							=      i == len(snake_case__ ) - 1

                 if down_block_type == "CrossAttnDownBlock2D":
                        snake_case       :   List[Any]							=      FlaxCrossAttnDownBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						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]    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)
                 else:
                        snake_case       :   Union[str, Any]							=      FlaxDownBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						dropout=self.dropout    ,						num_layers=self.layers_per_block    ,						add_downsample=not is_final_block    ,						dtype=self.dtype    ,						)

                 down_blocks.append(snake_case__ )
          snake_case       :   Dict							=      down_blocks

          # mid
          snake_case       :   Optional[int]							=      FlaxUNetMidBlockaDCrossAttn(
              in_channels=block_out_channels[-1]    ,						dropout=self.dropout    ,						num_attention_heads=num_attention_heads[-1]    ,						use_linear_projection=self.use_linear_projection    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)

          # up
          snake_case       :   Optional[Any]							=      []
          snake_case       :   Optional[int]							=      list(reversed(snake_case__ ) )
          snake_case       :   Dict							=      list(reversed(snake_case__ ) )
          snake_case       :   Tuple							=      list(reversed(snake_case__ ) )
          snake_case       :   Optional[Any]							=      reversed_block_out_channels[0]
          for i, up_block_type in enumerate(self.up_block_types ):
                 snake_case       :   Optional[int]							=      output_channel
                 snake_case       :   List[Any]							=      reversed_block_out_channels[i]
                 snake_case       :   Union[str, Any]							=      reversed_block_out_channels[min(i + 1    ,						len(snake_case__ ) - 1 )]

                 snake_case       :   int							=      i == len(snake_case__ ) - 1

                 if up_block_type == "CrossAttnUpBlock2D":
                        snake_case       :   Any							=      FlaxCrossAttnUpBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						prev_output_channel=snake_case__    ,						num_layers=self.layers_per_block + 1    ,						num_attention_heads=reversed_num_attention_heads[i]    ,						add_upsample=not is_final_block    ,						dropout=self.dropout    ,						use_linear_projection=self.use_linear_projection    ,						only_cross_attention=only_cross_attention[i]    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)
                 else:
                        snake_case       :   Optional[int]							=      FlaxUpBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						prev_output_channel=snake_case__    ,						num_layers=self.layers_per_block + 1    ,						add_upsample=not is_final_block    ,						dropout=self.dropout    ,						dtype=self.dtype    ,						)

                 up_blocks.append(snake_case__ )
                 snake_case       :   Optional[int]							=      output_channel
          snake_case       :   Tuple							=      up_blocks

          # out
          snake_case       :   Optional[int]							=      nn.GroupNorm(num_groups=32    ,						epsilon=1e-5 )
          snake_case       :   List[str]							=      nn.Conv(
              self.out_channels    ,						kernel_size=(3, 3)    ,						strides=(1, 1)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)



   def __call__(self		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					Tuple=None    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					bool = True    ,						snake_case__		:					bool = False    ,						)		->	Union[FlaxUNetaDConditionOutput, Tuple]:


          '''simple docstring'''


          if not isinstance(snake_case__    ,						jnp.ndarray ):
                 snake_case       :   List[Any]							=      jnp.array([timesteps]    ,						dtype=jnp.intaa )
          elif isinstance(snake_case__    ,						jnp.ndarray ) and len(timesteps.shape ) == 0:
                 snake_case       :   Any							=      timesteps.astype(dtype=jnp.floataa )
                 snake_case       :   int							=      jnp.expand_dims(snake_case__    ,						0 )

          snake_case       :   str							=      self.time_proj(snake_case__ )
          snake_case       :   str							=      self.time_embedding(snake_case__ )

          # 2. pre-process
          snake_case       :   int							=      jnp.transpose(snake_case__    ,						(0, 2, 3, 1) )
          snake_case       :   List[Any]							=      self.conv_in(snake_case__ )

          # 3. down
          snake_case       :   Optional[int]							=      (sample,)
          for down_block in self.down_blocks:
                 if isinstance(snake_case__    ,						snake_case__ ):
                        snake_case				,					snake_case       :   List[Any]							=      down_block(snake_case__    ,						snake_case__    ,						snake_case__    ,						deterministic=not train )
                 else:
                        snake_case				,					snake_case       :   str							=      down_block(snake_case__    ,						snake_case__    ,						deterministic=not train )
                 down_block_res_samples += res_samples

          if down_block_additional_residuals is not None:
                 snake_case       :   Tuple							=      ()

                 for down_block_res_sample, down_block_additional_residual in zip(
                     snake_case__    ,						snake_case__ ):
                        down_block_res_sample += down_block_additional_residual
                        new_down_block_res_samples += (down_block_res_sample,)

                 snake_case       :   Optional[int]							=      new_down_block_res_samples

          # 4. mid
          snake_case       :   Optional[int]							=      self.mid_block(snake_case__    ,						snake_case__    ,						snake_case__    ,						deterministic=not train )

          if mid_block_additional_residual is not None:
                 sample += mid_block_additional_residual

          # 5. up
          for up_block in self.up_blocks:
                 snake_case       :   int							=      down_block_res_samples[-(self.layers_per_block + 1) :]
                 snake_case       :   Optional[Any]							=      down_block_res_samples[: -(self.layers_per_block + 1)]
                 if isinstance(snake_case__    ,						snake_case__ ):
                        snake_case       :   Optional[Any]							=      up_block(
                            snake_case__    ,						temb=snake_case__    ,						encoder_hidden_states=snake_case__    ,						res_hidden_states_tuple=snake_case__    ,						deterministic=not train    ,						)
                 else:
                        snake_case       :   Dict							=      up_block(snake_case__    ,						temb=snake_case__    ,						res_hidden_states_tuple=snake_case__    ,						deterministic=not train )

        # 6. post-process
          snake_case       :   List[str]							=      self.conv_norm_out(snake_case__ )
          snake_case       :   Any							=      nn.silu(snake_case__ )
          snake_case       :   Optional[int]							=      self.conv_out(snake_case__ )
          snake_case       :   Union[str, Any]							=      jnp.transpose(snake_case__    ,						(0, 3, 1, 2) )

          if not return_dict:
                 return (sample,)

          return FlaxUNetaDConditionOutput(sample=snake_case__ )





