

import collections
from typing import List, Optional, Union

from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging
from ..bert.tokenization_bert import BertTokenizer


A__						=							logging.get_logger(__name__)

A__						=							{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

A__						=							{
    "vocab_file": {
        "facebook/dpr-ctx_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-ctx_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-ctx_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-ctx_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}
A__						=							{
    "vocab_file": {
        "facebook/dpr-question_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-question_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-question_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-question_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}
A__						=							{
    "vocab_file": {
        "facebook/dpr-reader-single-nq-base": (
            "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-reader-multiset-base": (
            "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-reader-single-nq-base": (
            "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-reader-multiset-base": (
            "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}

A__						=							{
    "facebook/dpr-ctx_encoder-single-nq-base": 512,
    "facebook/dpr-ctx_encoder-multiset-base": 512,
}
A__						=							{
    "facebook/dpr-question_encoder-single-nq-base": 512,
    "facebook/dpr-question_encoder-multiset-base": 512,
}
A__						=							{
    "facebook/dpr-reader-single-nq-base": 512,
    "facebook/dpr-reader-multiset-base": 512,
}


A__						=							{
    "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True},
}
A__						=							{
    "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True},
}
A__						=							{
    "facebook/dpr-reader-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-reader-multiset-base": {"do_lower_case": True},
}

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   str       				=  VOCAB_FILES_NAMES
	_lowercase  :   int       				=  CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP
	_lowercase  :   Optional[Any]       				=  CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_lowercase  :   List[Any]       				=  CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   List[str]       				=  VOCAB_FILES_NAMES
	_lowercase  :   Dict       				=  QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP
	_lowercase  :   Tuple       				=  QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_lowercase  :   Optional[Any]       				=  QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION




A__						=							collections.namedtuple(
    "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"]
)

A__						=							collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"])


A__						=							r"\n    Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n    It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n    using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n    with the format:\n\n    ```\n    [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n    ```\n\n    Args:\n        questions (`str` or `List[str]`):\n            The questions to be encoded. You can specify one question for many passages. In this case, the question\n            will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n            `titles` or `texts`.\n        titles (`str` or `List[str]`):\n            The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n        texts (`str` or `List[str]`):\n            The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n        padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n            Activates and controls padding. Accepts the following values:\n\n            - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n              if provided).\n            - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided.\n            - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n              lengths).\n        truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n            Activates and controls truncation. Accepts the following values:\n\n            - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n              the maximum acceptable input length for the model if that argument is not provided. This will truncate\n              token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n              of pairs) is provided.\n            - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the first\n              sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the\n              second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n              greater than the model maximum admissible input size).\n        max_length (`int`, *optional*):\n                Controls the maximum length to use by one of the truncation/padding parameters.\n\n                If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n                is required by one of the truncation/padding parameters. If the model has no specific maximum input\n                length (like XLNet) truncation/padding to a maximum length will be deactivated.\n        return_tensors (`str` or [`~utils.TensorType`], *optional*):\n                If set, will return tensors instead of list of python integers. Acceptable values are:\n\n                - `'tf'`: Return TensorFlow `tf.constant` objects.\n                - `'pt'`: Return PyTorch `torch.Tensor` objects.\n                - `'np'`: Return Numpy `np.ndarray` objects.\n        return_attention_mask (`bool`, *optional*):\n            Whether or not to return the attention mask. If not set, will return the attention mask according to the\n            specific tokenizer's default, defined by the `return_outputs` attribute.\n\n            [What are attention masks?](../glossary#attention-mask)\n\n    Returns:\n        `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n        - `input_ids`: List of token ids to be fed to a model.\n        - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n    "

@add_start_docstrings(SCREAMING_SNAKE_CASE			)
class 				__UpperCamelCase				:







	def __call__(   self: Tuple  , __UpperCamelCase: Any  , __UpperCamelCase: Optional[str] = None  , __UpperCamelCase: Optional[str] = None  , __UpperCamelCase: Union[bool, str] = False  , __UpperCamelCase: Union[bool, str] = False  , __UpperCamelCase: Optional[int] = None  , __UpperCamelCase: Optional[Union[str, TensorType]] = None  , __UpperCamelCase: Optional[bool] = None  , **__UpperCamelCase: Dict  , ):

						'''simple docstring'''





						if titles is None and texts is None:
											return super().__call__(
											    __UpperCamelCase  , padding=__UpperCamelCase  , truncation=__UpperCamelCase  , max_length=__UpperCamelCase  , return_tensors=__UpperCamelCase  , return_attention_mask=__UpperCamelCase  , **__UpperCamelCase  , )
						elif titles is None or texts is None:
											__magic_name__							=    titles if texts is None else texts
											return super().__call__(
											    __UpperCamelCase  , __UpperCamelCase  , padding=__UpperCamelCase  , truncation=__UpperCamelCase  , max_length=__UpperCamelCase  , return_tensors=__UpperCamelCase  , return_attention_mask=__UpperCamelCase  , **__UpperCamelCase  , )
						__magic_name__							=    titles if not isinstance(__UpperCamelCase  , __UpperCamelCase      ) else [titles]
						__magic_name__							=    texts if not isinstance(__UpperCamelCase  , __UpperCamelCase      ) else [texts]
						__magic_name__							=    len(__UpperCamelCase      )
						__magic_name__							=    questions if not isinstance(__UpperCamelCase  , __UpperCamelCase      ) else [questions] * n_passages
						if len(__UpperCamelCase      ) != len(__UpperCamelCase      ):
											raise ValueError(
											    F'There should be as many titles than texts but got {len(__UpperCamelCase      )} titles and {len(__UpperCamelCase      )} texts.'      )
						__magic_name__							=    super().__call__(__UpperCamelCase  , __UpperCamelCase  , padding=__UpperCamelCase  , truncation=__UpperCamelCase      )['input_ids']
						__magic_name__							=    super().__call__(__UpperCamelCase  , add_special_tokens=__UpperCamelCase  , padding=__UpperCamelCase  , truncation=__UpperCamelCase      )['input_ids']
						__magic_name__							=    {
						    'input_ids': [
						        (encoded_question_and_title + encoded_text)[:max_length]
						        if max_length is not None and truncation
						        else encoded_question_and_title + encoded_text
						        for encoded_question_and_title, encoded_text in zip(__UpperCamelCase  , __UpperCamelCase      )
						    ]
						}
						if return_attention_mask is not False:
											__magic_name__							=    []
											for input_ids in encoded_inputs["input_ids"]:
																attention_mask.append([int(input_id != self.pad_token_id      ) for input_id in input_ids]      )
											__magic_name__							=    attention_mask
						return self.pad(__UpperCamelCase  , padding=__UpperCamelCase  , max_length=__UpperCamelCase  , return_tensors=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]  , __UpperCamelCase: BatchEncoding  , __UpperCamelCase: DPRReaderOutput  , __UpperCamelCase: int = 16  , __UpperCamelCase: int = 64  , __UpperCamelCase: int = 4  , ):

						'''simple docstring'''





						__magic_name__							=    reader_input['input_ids']
						__magic_name__,	__magic_name__,	__magic_name__							=    reader_output[:3]
						__magic_name__							=    len(__UpperCamelCase      )
						__magic_name__							=    sorted(range(__UpperCamelCase      )  , reverse=__UpperCamelCase  , key=relevance_logits.__getitem__      )
						__magic_name__							=    []
						for doc_id in sorted_docs:
											__magic_name__							=    list(input_ids[doc_id]      )
											# assuming question & title information is at the beginning of the sequence
											__magic_name__							=    sequence_ids.index(self.sep_token_id  , 2      ) + 1  # second sep id
											if sequence_ids[-1] == self.pad_token_id:
																__magic_name__							=    sequence_ids.index(self.pad_token_id      )
											else:
																__magic_name__							=    len(__UpperCamelCase      )

											__magic_name__							=    self._get_best_spans(
											    start_logits=start_logits[doc_id][passage_offset:sequence_len]  , end_logits=end_logits[doc_id][passage_offset:sequence_len]  , max_answer_length=__UpperCamelCase  , top_spans=__UpperCamelCase  , )
											for start_index, end_index in best_spans:
																start_index += passage_offset
																end_index += passage_offset
																nbest_spans_predictions.append(
																    DPRSpanPrediction(
																        span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index]  , relevance_score=relevance_logits[doc_id]  , doc_id=__UpperCamelCase  , start_index=__UpperCamelCase  , end_index=__UpperCamelCase  , text=self.decode(sequence_ids[start_index : end_index + 1]      )  , )      )
											if len(__UpperCamelCase      ) >= num_spans:
																break
						return nbest_spans_predictions[:num_spans]







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]  , __UpperCamelCase: List[int]  , __UpperCamelCase: List[int]  , __UpperCamelCase: int  , __UpperCamelCase: int  , ):

						'''simple docstring'''





						__magic_name__							=    []
						for start_index, start_score in enumerate(__UpperCamelCase      ):
											for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]      ):
																scores.append(((start_index, start_index + answer_length), start_score + end_score)      )
						__magic_name__							=    sorted(__UpperCamelCase  , key=lambda __UpperCamelCase      : x[1]  , reverse=__UpperCamelCase      )
						__magic_name__							=    []
						for (start_index, end_index), score in scores:
											if start_index > end_index:
																raise ValueError(F'Wrong span indices: [{start_index}:{end_index}]'      )
											__magic_name__							=    end_index - start_index + 1
											if length > max_answer_length:
																raise ValueError(F'Span is too long: {length} > {max_answer_length}'      )
											if any(
											    start_index <= prev_start_index <= prev_end_index <= end_index
											    or prev_start_index <= start_index <= end_index <= prev_end_index
											    for (prev_start_index, prev_end_index) in chosen_span_intervals      ):
																continue
											chosen_span_intervals.append((start_index, end_index)      )

											if len(__UpperCamelCase      ) == top_spans:
																break
						return chosen_span_intervals




@add_end_docstrings(SCREAMING_SNAKE_CASE			)
class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE			):
	_lowercase  :   str       				=  VOCAB_FILES_NAMES
	_lowercase  :   Tuple       				=  READER_PRETRAINED_VOCAB_FILES_MAP
	_lowercase  :   Dict       				=  READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_lowercase  :   List[str]       				=  READER_PRETRAINED_INIT_CONFIGURATION
	_lowercase  :   str       				=  ["input_ids", "attention_mask"]







import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   str       				=  DownBlockaD  # noqa F405
	_lowercase  :   Union[str, Any]       				=  "down"







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    [-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[str]       				=  ResnetDownsampleBlockaD  # noqa F405
	_lowercase  :   Union[str, Any]       				=  "down"







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						__magic_name__							=    [0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Dict       				=  AttnDownBlockaD  # noqa F405
	_lowercase  :   List[Any]       				=  "down"







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						__magic_name__							=    [0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   int       				=  CrossAttnDownBlockaD  # noqa F405
	_lowercase  :   Any       				=  "down"







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						__magic_name__							=    [0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Union[str, Any]       				=  SimpleCrossAttnDownBlockaD  # noqa F405
	_lowercase  :   List[str]       				=  "down"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						return super().get_dummy_input(include_encoder_hidden_states=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	@unittest.skipIf(torch_device == 'mps'  , 'MPS result is not consistent'      )
	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__							=    [0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   str       				=  SkipDownBlockaD  # noqa F405
	_lowercase  :   Union[str, Any]       				=  "down"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_skip_sample=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    [-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Tuple       				=  AttnSkipDownBlockaD  # noqa F405
	_lowercase  :   str       				=  "down"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_skip_sample=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    [0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Optional[int]       				=  DownEncoderBlockaD  # noqa F405
	_lowercase  :   List[str]       				=  "down"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_temb=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    {
						    'in_channels': 32,
						    'out_channels': 32,
						}
						__magic_name__							=    self.dummy_input
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    [1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[Any]       				=  AttnDownEncoderBlockaD  # noqa F405
	_lowercase  :   Optional[Any]       				=  "down"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_temb=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						__magic_name__							=    {
						    'in_channels': 32,
						    'out_channels': 32,
						}
						__magic_name__							=    self.dummy_input
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    [0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[Any]       				=  UNetMidBlockaD  # noqa F405
	_lowercase  :   Any       				=  "mid"







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    {
						    'in_channels': 32,
						    'temb_channels': 1_28,
						}
						__magic_name__							=    self.dummy_input
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						__magic_name__							=    [-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   str       				=  UNetMidBlockaDCrossAttn  # noqa F405
	_lowercase  :   int       				=  "mid"







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						__magic_name__							=    [0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Tuple       				=  UNetMidBlockaDSimpleCrossAttn  # noqa F405
	_lowercase  :   str       				=  "mid"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						return super().get_dummy_input(include_encoder_hidden_states=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						__magic_name__							=    [0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[Any]       				=  UpBlockaD  # noqa F405
	_lowercase  :   List[Any]       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						__magic_name__							=    [-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[Any]       				=  ResnetUpsampleBlockaD  # noqa F405
	_lowercase  :   Dict       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    [0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Any       				=  CrossAttnUpBlockaD  # noqa F405
	_lowercase  :   Union[str, Any]       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						__magic_name__							=    [-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   str       				=  SimpleCrossAttnUpBlockaD  # noqa F405
	_lowercase  :   Tuple       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase  , include_encoder_hidden_states=__UpperCamelCase      )







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

						'''simple docstring'''





						__magic_name__,	__magic_name__							=    super().prepare_init_args_and_inputs_for_common()
						__magic_name__							=    32
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__							=    [0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Optional[Any]       				=  AttnUpBlockaD  # noqa F405
	_lowercase  :   Optional[int]       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







	@unittest.skipIf(torch_device == 'mps'  , 'MPS result is not consistent'      )
	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





						__magic_name__							=    [0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Union[str, Any]       				=  SkipUpBlockaD  # noqa F405
	_lowercase  :   int       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







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

						'''simple docstring'''





						__magic_name__							=    [-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Union[str, Any]       				=  AttnSkipUpBlockaD  # noqa F405
	_lowercase  :   Optional[Any]       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_res_hidden_states_tuple=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						__magic_name__							=    [0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   List[str]       				=  UpDecoderBlockaD  # noqa F405
	_lowercase  :   List[str]       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						return super().get_dummy_input(include_temb=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__							=    {'in_channels': 32, 'out_channels': 32}

						__magic_name__							=    self.dummy_input
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						__magic_name__							=    [0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
						super().test_output(__UpperCamelCase      )




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Optional[Any]       				=  AttnUpDecoderBlockaD  # noqa F405
	_lowercase  :   Any       				=  "up"







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						return super().get_dummy_input(include_temb=__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						__magic_name__							=    {'in_channels': 32, 'out_channels': 32}

						__magic_name__							=    self.dummy_input
						return init_dict, inputs_dict







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

						'''simple docstring'''





						__magic_name__							=    [0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
						super().test_output(__UpperCamelCase      )




