
'''simple docstring'''



import importlib
import inspect
import json
import os
import re
import shutil
import sys
from pathlib import Path
from typing import Dict, Optional, Union
from urllib import request

from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info
from packaging import version

from .. import __version__
from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging


_lowercase    =		(
    """https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py"""
)


_lowercase    =		logging.get_logger(__name__)  # pylint: disable=invalid-name


def A				():
						_lowerCAmelCase  						=			"""https://pypi.org/pypi/diffusers/json"""
						_lowerCAmelCase  						=			json.loads(request.urlopen(__lowerCamelCase		).read()		)["""releases"""].keys()
						return sorted(__lowerCamelCase			,     key=lambda __lowerCamelCase		: version.Version(__lowerCamelCase		)		)


def A				():
						# This function has already been executed if HF_MODULES_CACHE already is in the Python path.
						if HF_MODULES_CACHE in sys.path:
												return

						sys.path.append(__lowerCamelCase		)
						os.makedirs(__lowerCamelCase			,     exist_ok=__lowerCamelCase		)
						_lowerCAmelCase  						=			Path(__lowerCamelCase		) / """__init__.py"""
						if not init_path.exists():
												init_path.touch()


def A				(__lowerCamelCase				:Union[str, os.PathLike]		):
						init_hf_modules()
						_lowerCAmelCase  						=			Path(__lowerCamelCase		) / name
						# If the parent module does not exist yet, recursively create it.
						if not dynamic_module_path.parent.exists():
												create_dynamic_module(dynamic_module_path.parent		)
						os.makedirs(__lowerCamelCase			,     exist_ok=__lowerCamelCase		)
						_lowerCAmelCase  						=			dynamic_module_path / """__init__.py"""
						if not init_path.exists():
												init_path.touch()


def A				(__lowerCamelCase				:List[str]		):
						with open(__lowerCamelCase			,     """r"""			,     encoding="""utf-8"""		) as f:
												_lowerCAmelCase  						=			f.read()

						# Imports of the form `import .xxx`
						_lowerCAmelCase  						=			re.findall("""^\s*import\s+\.(\S+)\s*$"""			,     __lowerCamelCase			,     flags=re.MULTILINE		)
						# Imports of the form `from .xxx import yyy`
						relative_imports += re.findall("""^\s*from\s+\.(\S+)\s+import"""			,     __lowerCamelCase			,     flags=re.MULTILINE		)
						# Unique-ify
						return list(set(__lowerCamelCase		)		)


def A				(__lowerCamelCase				:List[Any]		):
						_lowerCAmelCase  						=			False
						_lowerCAmelCase  						=			[module_file]
						_lowerCAmelCase  						=			[]

						# Let's recurse through all relative imports
						while not no_change:
												_lowerCAmelCase  						=			[]
												for f in files_to_check:
																		new_imports.extend(get_relative_imports(__lowerCamelCase		)		)

												_lowerCAmelCase  						=			Path(__lowerCamelCase		).parent
												_lowerCAmelCase  						=			[str(module_path / m		) for m in new_imports]
												_lowerCAmelCase  						=			[f for f in new_import_files if f not in all_relative_imports]
												_lowerCAmelCase  						=			[f'{f}.py' for f in new_import_files]

												_lowerCAmelCase  						=			len(__lowerCamelCase		) == 0
												all_relative_imports.extend(__lowerCamelCase		)

						return all_relative_imports


def A				(__lowerCamelCase				:Optional[int]		):
						with open(__lowerCamelCase			,     """r"""			,     encoding="""utf-8"""		) as f:
												_lowerCAmelCase  						=			f.read()

						# Imports of the form `import xxx`
						_lowerCAmelCase  						=			re.findall("""^\s*import\s+(\S+)\s*$"""			,     __lowerCamelCase			,     flags=re.MULTILINE		)
						# Imports of the form `from xxx import yyy`
						imports += re.findall("""^\s*from\s+(\S+)\s+import"""			,     __lowerCamelCase			,     flags=re.MULTILINE		)
						# Only keep the top-level module
						_lowerCAmelCase  						=			[imp.split("""."""		)[0] for imp in imports if not imp.startswith("""."""		)]

						# Unique-ify and test we got them all
						_lowerCAmelCase  						=			list(set(__lowerCamelCase		)		)
						_lowerCAmelCase  						=			[]
						for imp in imports:
												try:
																		importlib.import_module(__lowerCamelCase		)
												except ImportError:
																		missing_packages.append(__lowerCamelCase		)

						if len(__lowerCamelCase		) > 0:
												raise ImportError(
												    """This modeling file requires the following packages that were not found in your environment: """
												    f'{", ".join(__lowerCamelCase		)}. Run `pip install {" ".join(__lowerCamelCase		)}`'		)

						return get_relative_imports(__lowerCamelCase		)


def A				(__lowerCamelCase				:List[Any]			,     __lowerCamelCase				:Optional[int]		):
						_lowerCAmelCase  						=			module_path.replace(os.path.sep			,     """."""		)
						_lowerCAmelCase  						=			importlib.import_module(__lowerCamelCase		)

						if class_name is None:
												return find_pipeline_class(__lowerCamelCase		)
						return getattr(__lowerCamelCase			,     __lowerCamelCase		)


def A				(__lowerCamelCase				:Union[str, Any]		):
						from ..pipelines import DiffusionPipeline

						_lowerCAmelCase  						=			dict(inspect.getmembers(__lowerCamelCase			,     inspect.isclass		)		)

						_lowerCAmelCase  						=			None
						for cls_name, cls in cls_members.items():
												if (
												    cls_name != DiffusionPipeline.__name__
												    and issubclass(cls			,     __lowerCamelCase		)
												    and cls.__module__.split("""."""		)[0] != "diffusers"
												):
																		if pipeline_class is not None:
																								raise ValueError(
																								    f'Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:'
																								    f' {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in'
																								    f' {loaded_module}.'		)
																		_lowerCAmelCase  						=			cls

						return pipeline_class


def A				(__lowerCamelCase				:Union[str, os.PathLike]			,     __lowerCamelCase				:str			,     __lowerCamelCase				:Optional[Union[str, os.PathLike]] = None			,     __lowerCamelCase				:bool = False			,     __lowerCamelCase				:bool = False			,     __lowerCamelCase				:Optional[Dict[str, str]] = None			,     __lowerCamelCase				:Optional[Union[bool, str]] = None			,     __lowerCamelCase				:Optional[str] = None			,     __lowerCamelCase				:bool = False			,     ):
						_lowerCAmelCase  						=			str(__lowerCamelCase		)

						_lowerCAmelCase  						=			os.path.join(__lowerCamelCase			,     __lowerCamelCase		)

						if os.path.isfile(__lowerCamelCase		):
												_lowerCAmelCase  						=			module_file_or_url
												_lowerCAmelCase  						=			"""local"""
						elif pretrained_model_name_or_path.count("""/"""		) == 0:
												_lowerCAmelCase  						=			get_diffusers_versions()
												# cut ".dev0"
												_lowerCAmelCase  						=			"""v""" + """.""".join(__version__.split("""."""		)[:3]		)

												# retrieve github version that matches
												if revision is None:
																		_lowerCAmelCase  						=			latest_version if latest_version[1:] in available_versions else """main"""
																		logger.info(f'Defaulting to latest_version: {revision}.'		)
												elif revision in available_versions:
																		_lowerCAmelCase  						=			f'v{revision}'
												elif revision == "main":
																		_lowerCAmelCase  						=			revision
												else:
																		raise ValueError(
																		    f'`custom_revision`: {revision} does not exist. Please make sure to choose one of'
																		    f' {", ".join(available_versions + ["main"]		)}.'		)

												# community pipeline on GitHub
												_lowerCAmelCase  						=			COMMUNITY_PIPELINES_URL.format(revision=__lowerCamelCase			,     pipeline=__lowerCamelCase		)
												try:
																		_lowerCAmelCase  						=			cached_download(
																		    __lowerCamelCase			,     cache_dir=__lowerCamelCase			,     force_download=__lowerCamelCase			,     proxies=__lowerCamelCase			,     resume_download=__lowerCamelCase			,     local_files_only=__lowerCamelCase			,     use_auth_token=__lowerCamelCase			,     )
																		_lowerCAmelCase  						=			"""git"""
																		_lowerCAmelCase  						=			pretrained_model_name_or_path + """.py"""
												except EnvironmentError:
																		logger.error(f'Could not locate the {module_file} inside {pretrained_model_name_or_path}.'		)
																		raise
						else:
												try:
																		# Load from URL or cache if already cached
																		_lowerCAmelCase  						=			hf_hub_download(
																		    __lowerCamelCase			,     __lowerCamelCase			,     cache_dir=__lowerCamelCase			,     force_download=__lowerCamelCase			,     proxies=__lowerCamelCase			,     resume_download=__lowerCamelCase			,     local_files_only=__lowerCamelCase			,     use_auth_token=__lowerCamelCase			,     )
																		_lowerCAmelCase  						=			os.path.join("""local"""			,     """--""".join(pretrained_model_name_or_path.split("""/"""		)		)		)
												except EnvironmentError:
																		logger.error(f'Could not locate the {module_file} inside {pretrained_model_name_or_path}.'		)
																		raise

    # Check we have all the requirements in our environment
						_lowerCAmelCase  						=			check_imports(__lowerCamelCase		)

						# Now we move the module inside our cached dynamic modules.
						_lowerCAmelCase  						=			DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
						create_dynamic_module(__lowerCamelCase		)
						_lowerCAmelCase  						=			Path(__lowerCamelCase		) / full_submodule
						if submodule == "local" or submodule == "git":
												# We always copy local files (we could hash the file to see if there was a change, and give them the name of
												# that hash, to only copy when there is a modification but it seems overkill for now).
												# The only reason we do the copy is to avoid putting too many folders in sys.path.
												shutil.copy(__lowerCamelCase			,     submodule_path / module_file		)
												for module_needed in modules_needed:
																		_lowerCAmelCase  						=			f'{module_needed}.py'
																		shutil.copy(os.path.join(__lowerCamelCase			,     __lowerCamelCase		)			,     submodule_path / module_needed		)
						else:
												# Get the commit hash
												# TODO: we will get this info in the etag soon, so retrieve it from there and not here.
												if isinstance(__lowerCamelCase			,     __lowerCamelCase		):
																		_lowerCAmelCase  						=			use_auth_token
												elif use_auth_token is True:
																		_lowerCAmelCase  						=			HfFolder.get_token()
												else:
																		_lowerCAmelCase  						=			None

												_lowerCAmelCase  						=			model_info(__lowerCamelCase			,     revision=__lowerCamelCase			,     token=__lowerCamelCase		).sha

												# The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the
												# benefit of versioning.
												_lowerCAmelCase  						=			submodule_path / commit_hash
												_lowerCAmelCase  						=			full_submodule + os.path.sep + commit_hash
												create_dynamic_module(__lowerCamelCase		)

												if not (submodule_path / module_file).exists():
																		shutil.copy(__lowerCamelCase			,     submodule_path / module_file		)
												# Make sure we also have every file with relative
												for module_needed in modules_needed:
																		if not (submodule_path / module_needed).exists():
																								get_cached_module_file(
																								    __lowerCamelCase			,     f'{module_needed}.py'			,     cache_dir=__lowerCamelCase			,     force_download=__lowerCamelCase			,     resume_download=__lowerCamelCase			,     proxies=__lowerCamelCase			,     use_auth_token=__lowerCamelCase			,     revision=__lowerCamelCase			,     local_files_only=__lowerCamelCase			,     )
						return os.path.join(__lowerCamelCase			,     __lowerCamelCase		)





def A				(__lowerCamelCase				:Union[str, os.PathLike]			,     __lowerCamelCase				:str			,     __lowerCamelCase				:Optional[str] = None			,     __lowerCamelCase				:Optional[Union[str, os.PathLike]] = None			,     __lowerCamelCase				:bool = False			,     __lowerCamelCase				:bool = False			,     __lowerCamelCase				:Optional[Dict[str, str]] = None			,     __lowerCamelCase				:Optional[Union[bool, str]] = None			,     __lowerCamelCase				:Optional[str] = None			,     __lowerCamelCase				:bool = False			,     **__lowerCamelCase				:Optional[int]			,     ):
						_lowerCAmelCase  						=			get_cached_module_file(
						    __lowerCamelCase			,     __lowerCamelCase			,     cache_dir=__lowerCamelCase			,     force_download=__lowerCamelCase			,     resume_download=__lowerCamelCase			,     proxies=__lowerCamelCase			,     use_auth_token=__lowerCamelCase			,     revision=__lowerCamelCase			,     local_files_only=__lowerCamelCase			,     )
						return get_class_in_module(__lowerCamelCase			,     final_module.replace(""".py"""			,     """"""		)		)


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




@flax.struct.dataclass
class   UpperCAmelCase_					(		_SCREAMING_SNAKE_CASE			):






						'''simple docstring'''






						_lowercase		:				jnp.ndarray






@flax_register_to_config
class   UpperCAmelCase_					(		nn.Module	,							_SCREAMING_SNAKE_CASE	,							_SCREAMING_SNAKE_CASE			):






						'''simple docstring'''






						_lowercase		:				int									=       3_2
						_lowercase		:				int									=       4
						_lowercase		:				int									=       4
						_lowercase		:				Tuple[str]									=       (
						    "CrossAttnDownBlock2D",
						    "CrossAttnDownBlock2D",
						    "CrossAttnDownBlock2D",
						    "DownBlock2D",
						)
						_lowercase		:				Tuple[str]									=       ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
						_lowercase		:				Union[bool, Tuple[bool]]									=       False
						_lowercase		:				Tuple[int]									=       (3_2_0, 6_4_0, 1_2_8_0, 1_2_8_0)
						_lowercase		:				int									=       2
						_lowercase		:				Union[int, Tuple[int]]									=       8
						_lowercase		:				Optional[Union[int, Tuple[int]]]									=       None
						_lowercase		:				int									=       1_2_8_0
						_lowercase		:				float									=       0.0
						_lowercase		:				bool									=       False
						_lowercase		:				jnp.dtype									=       jnp.floataa
						_lowercase		:				bool									=       True
						_lowercase		:				int									=       0
						_lowercase		:				bool									=       False




						def  _lowercase     ( self   ,       _lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			(1, self.in_channels, self.sample_size, self.sample_size)
												_lowerCAmelCase  						=			jnp.zeros(_lowercase   ,       dtype=jnp.floataa				)
												_lowerCAmelCase  						=			jnp.ones((1,)   ,       dtype=jnp.intaa				)
												_lowerCAmelCase  						=			jnp.zeros((1, 1, self.cross_attention_dim)   ,       dtype=jnp.floataa				)

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

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.block_out_channels
												_lowerCAmelCase  						=			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.
												_lowerCAmelCase  						=			self.num_attention_heads or self.attention_head_dim

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

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

												_lowerCAmelCase  						=			self.only_cross_attention
												if isinstance(_lowercase   ,       _lowercase				):
																		_lowerCAmelCase  						=			(only_cross_attention,) * len(self.down_block_types				)

												if isinstance(_lowercase   ,       _lowercase				):
																		_lowerCAmelCase  						=			(num_attention_heads,) * len(self.down_block_types				)

												# down
												_lowerCAmelCase  						=			[]
												_lowerCAmelCase  						=			block_out_channels[0]
												for i, down_block_type in enumerate(self.down_block_types				):
																		_lowerCAmelCase  						=			output_channel
																		_lowerCAmelCase  						=			block_out_channels[i]
																		_lowerCAmelCase  						=			i == len(_lowercase				) - 1

																		if down_block_type == "CrossAttnDownBlock2D":
																								_lowerCAmelCase  						=			FlaxCrossAttnDownBlockaD(
																								    in_channels=_lowercase   ,       out_channels=_lowercase   ,       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:
																								_lowerCAmelCase  						=			FlaxDownBlockaD(
																								    in_channels=_lowercase   ,       out_channels=_lowercase   ,       dropout=self.dropout   ,       num_layers=self.layers_per_block   ,       add_downsample=not is_final_block   ,       dtype=self.dtype   ,       )

																		down_blocks.append(_lowercase				)
												_lowerCAmelCase  						=			down_blocks

												# mid
												_lowerCAmelCase  						=			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
												_lowerCAmelCase  						=			[]
												_lowerCAmelCase  						=			list(reversed(_lowercase				)				)
												_lowerCAmelCase  						=			list(reversed(_lowercase				)				)
												_lowerCAmelCase  						=			list(reversed(_lowercase				)				)
												_lowerCAmelCase  						=			reversed_block_out_channels[0]
												for i, up_block_type in enumerate(self.up_block_types				):
																		_lowerCAmelCase  						=			output_channel
																		_lowerCAmelCase  						=			reversed_block_out_channels[i]
																		_lowerCAmelCase  						=			reversed_block_out_channels[min(i + 1   ,       len(_lowercase				) - 1				)]

																		_lowerCAmelCase  						=			i == len(_lowercase				) - 1

																		if up_block_type == "CrossAttnUpBlock2D":
																								_lowerCAmelCase  						=			FlaxCrossAttnUpBlockaD(
																								    in_channels=_lowercase   ,       out_channels=_lowercase   ,       prev_output_channel=_lowercase   ,       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:
																								_lowerCAmelCase  						=			FlaxUpBlockaD(
																								    in_channels=_lowercase   ,       out_channels=_lowercase   ,       prev_output_channel=_lowercase   ,       num_layers=self.layers_per_block + 1   ,       add_upsample=not is_final_block   ,       dropout=self.dropout   ,       dtype=self.dtype   ,       )

																		up_blocks.append(_lowercase				)
																		_lowerCAmelCase  						=			output_channel
												_lowerCAmelCase  						=			up_blocks

												# out
												_lowerCAmelCase  						=			nn.GroupNorm(num_groups=32   ,       epsilon=1e-5				)
												_lowerCAmelCase  						=			nn.Conv(
												    self.out_channels   ,       kernel_size=(3, 3)   ,       strides=(1, 1)   ,       padding=((1, 1), (1, 1))   ,       dtype=self.dtype   ,       )




						def __call__( self   ,       _lowercase   ,       _lowercase   ,       _lowercase   ,       _lowercase=None   ,       _lowercase=None   ,       _lowercase = True   ,       _lowercase = False   ,       ):

												"""simple docstring"""



												if not isinstance(_lowercase   ,       jnp.ndarray				):
																		_lowerCAmelCase  						=			jnp.array([timesteps]   ,       dtype=jnp.intaa				)
												elif isinstance(_lowercase   ,       jnp.ndarray				) and len(timesteps.shape				) == 0:
																		_lowerCAmelCase  						=			timesteps.astype(dtype=jnp.floataa				)
																		_lowerCAmelCase  						=			jnp.expand_dims(_lowercase   ,       0				)

												_lowerCAmelCase  						=			self.time_proj(_lowercase				)
												_lowerCAmelCase  						=			self.time_embedding(_lowercase				)

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

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

												if down_block_additional_residuals is not None:
																		_lowerCAmelCase  						=			()

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

																		_lowerCAmelCase  						=			new_down_block_res_samples

												# 4. mid
												_lowerCAmelCase  						=			self.mid_block(_lowercase   ,       _lowercase   ,       _lowercase   ,       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:
																		_lowerCAmelCase  						=			down_block_res_samples[-(self.layers_per_block + 1) :]
																		_lowerCAmelCase  						=			down_block_res_samples[: -(self.layers_per_block + 1)]
																		if isinstance(_lowercase   ,       _lowercase				):
																								_lowerCAmelCase  						=			up_block(
																								    _lowercase   ,       temb=_lowercase   ,       encoder_hidden_states=_lowercase   ,       res_hidden_states_tuple=_lowercase   ,       deterministic=not train   ,       )
																		else:
																								_lowerCAmelCase  						=			up_block(_lowercase   ,       temb=_lowercase   ,       res_hidden_states_tuple=_lowercase   ,       deterministic=not train				)

        # 6. post-process
												_lowerCAmelCase  						=			self.conv_norm_out(_lowercase				)
												_lowerCAmelCase  						=			nn.silu(_lowercase				)
												_lowerCAmelCase  						=			self.conv_out(_lowercase				)
												_lowerCAmelCase  						=			jnp.transpose(_lowercase   ,       (0, 3, 1, 2)				)

												if not return_dict:
																		return (sample,)

												return FlaxUNetaDConditionOutput(sample=_lowercase				)
