
import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
				import ctypes
				import msvcrt  # noqa




				class 						lowercase__  (						ctypes.Structure  ):
					# _fields is a specific attr expected by ctypes
					A__    :   List[Any]				       =[("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)]






def 							_lowercase							(     )		->		Union[str, Any]:
					'''simple docstring'''


					if os.name == "nt":
										SCREAMING_SNAKE_CASE__													= CursorInfo()
										SCREAMING_SNAKE_CASE__													= ctypes.windll.kernelaa.GetStdHandle(-11		)
										ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCamelCase_	,	ctypes.byref(UpperCamelCase_		)		)
										SCREAMING_SNAKE_CASE__													= False
										ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCamelCase_	,	ctypes.byref(UpperCamelCase_		)		)
					elif os.name == "posix":
										sys.stdout.write('\033[?25l'		)
										sys.stdout.flush()






def 							_lowercase							(     )		->		Dict:
					'''simple docstring'''


					if os.name == "nt":
										SCREAMING_SNAKE_CASE__													= CursorInfo()
										SCREAMING_SNAKE_CASE__													= ctypes.windll.kernelaa.GetStdHandle(-11		)
										ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCamelCase_	,	ctypes.byref(UpperCamelCase_		)		)
										SCREAMING_SNAKE_CASE__													= True
										ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCamelCase_	,	ctypes.byref(UpperCamelCase_		)		)
					elif os.name == "posix":
										sys.stdout.write('\033[?25h'		)
										sys.stdout.flush()






@contextmanager
def 							_lowercase							(     )		->		Optional[Any]:
					'''simple docstring'''


					try:
										hide_cursor()
										yield
					finally:
										show_cursor()







import flax.linen as nn
import jax.numpy as jnp

from .attention_flax import FlaxTransformeraDModel
from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD




class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= []
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=UpperCAmelCase_       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.out_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.out_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   only_cross_attention=self.only_cross_attention       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= FlaxDownsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   int       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Tuple       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   int=True							):
						SCREAMING_SNAKE_CASE__													= ()

						for resnet, attn in zip(self.resnets       ,   self.attentions							):
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											output_states += (hidden_states,)

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= self.downsamplers_a(UpperCAmelCase_							)
											output_states += (hidden_states,)

						return hidden_states, output_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=UpperCAmelCase_       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= resnets

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= FlaxDownsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   List[str]       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Union[str, Any]       ,   UpperCAmelCase_							:   List[Any]=True							):
						SCREAMING_SNAKE_CASE__													= ()

						for resnet in self.resnets:
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											output_states += (hidden_states,)

						if self.add_downsample:
											SCREAMING_SNAKE_CASE__													= self.downsamplers_a(UpperCAmelCase_							)
											output_states += (hidden_states,)

						return hidden_states, output_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= []
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if (i == self.num_layers - 1) else self.out_channels
											SCREAMING_SNAKE_CASE__													= self.prev_output_channel if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.out_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.out_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   only_cross_attention=self.only_cross_attention       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= FlaxUpsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   str       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Union[str, Any]=True							):
						for resnet, attn in zip(self.resnets       ,   self.attentions							):
											# pop res hidden states
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[-1]
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[:-1]
											SCREAMING_SNAKE_CASE__													= jnp.concatenate((hidden_states, res_hidden_states)       ,   axis=-1							)

											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= self.upsamplers_a(UpperCAmelCase_							)

						return hidden_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   int
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   bool				       =True
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   List[Any]							):
						SCREAMING_SNAKE_CASE__													= []

						for i in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= self.in_channels if (i == self.num_layers - 1) else self.out_channels
											SCREAMING_SNAKE_CASE__													= self.prev_output_channel if i == 0 else self.out_channels

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels       ,   out_channels=self.out_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= FlaxUpsampleaD(self.out_channels       ,   dtype=self.dtype							)





	def __call__(			self							:   Tuple       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Dict=True							):
						for resnet in self.resnets:
											# pop res hidden states
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[-1]
											SCREAMING_SNAKE_CASE__													= res_hidden_states_tuple[:-1]
											SCREAMING_SNAKE_CASE__													= jnp.concatenate((hidden_states, res_hidden_states)       ,   axis=-1							)

											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						if self.add_upsample:
											SCREAMING_SNAKE_CASE__													= self.upsamplers_a(UpperCAmelCase_							)

						return hidden_states





class 						lowercase__  (						nn.Module  ):
	A__    :   int
	A__    :   float				       =0.0
	A__    :   int				       =1
	A__    :   int				       =1
	A__    :   bool				       =False
	A__    :   bool				       =False
	A__    :   jnp.dtype				       =jnp.floataa
	def      A_				(			self							:   Optional[int]							):
						# there is always at least one resnet
						SCREAMING_SNAKE_CASE__													= [
						    FlaxResnetBlockaD(
						        in_channels=self.in_channels       ,   out_channels=self.in_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
						]

						SCREAMING_SNAKE_CASE__													= []

						for _ in range(self.num_layers							):
											SCREAMING_SNAKE_CASE__													= FlaxTransformeraDModel(
											    in_channels=self.in_channels       ,   n_heads=self.num_attention_heads       ,   d_head=self.in_channels // self.num_attention_heads       ,   depth=1       ,   use_linear_projection=self.use_linear_projection       ,   use_memory_efficient_attention=self.use_memory_efficient_attention       ,   dtype=self.dtype       ,   )
											attentions.append(UpperCAmelCase_							)

											SCREAMING_SNAKE_CASE__													= FlaxResnetBlockaD(
											    in_channels=self.in_channels       ,   out_channels=self.in_channels       ,   dropout_prob=self.dropout       ,   dtype=self.dtype       ,   )
											resnets.append(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= resnets
						SCREAMING_SNAKE_CASE__													= attentions





	def __call__(			self							:   str       ,   UpperCAmelCase_							:   Union[str, Any]       ,   UpperCAmelCase_							:   Optional[int]       ,   UpperCAmelCase_							:   List[str]       ,   UpperCAmelCase_							:   Any=True							):
						SCREAMING_SNAKE_CASE__													= self.resnets[0](UpperCAmelCase_       ,   UpperCAmelCase_							)
						for attn, resnet in zip(self.attentions       ,   self.resnets[1:]							):
											SCREAMING_SNAKE_CASE__													= attn(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= resnet(UpperCAmelCase_       ,   UpperCAmelCase_       ,   deterministic=UpperCAmelCase_							)

						return hidden_states





