





import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__UpperCAmelCase	:       int    	=							logging.get_logger(__name__)


__UpperCAmelCase	:       Any    	=							{"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
__UpperCAmelCase	:       str    	=							{
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

__UpperCAmelCase	:       Optional[int]    	=							{
    "facebook/bart-base": 1_024,
    "facebook/bart-large": 1_024,
    "facebook/bart-large-mnli": 1_024,
    "facebook/bart-large-cnn": 1_024,
    "facebook/bart-large-xsum": 1_024,
    "yjernite/bart_eli5": 1_024,
}






@lru_cache()
def       A__							(   )       ->   List[str]:
  __snake_case:						Optional[int]			  =						(
      list(range(ord("""!""") , ord("""~""") + 1)) + list(range(ord("""¡""") , ord("""¬""") + 1)) + list(range(ord("""®""") , ord("""ÿ""") + 1))
  )
  __snake_case:						int			  =						bs[:]
  __snake_case:						Union[str, Any]			  =						0
  for b in range(2**8):
    if b not in bs:
      bs.append(SCREAMING_SNAKE_CASE__)
      cs.append(2**8 + n)
      n += 1
  __snake_case:						Dict			  =						[chr(SCREAMING_SNAKE_CASE__) for n in cs]
  return dict(zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__))






def       A__							(   SCREAMING_SNAKE_CASE__)       ->   str:
  __snake_case:						List[str]			  =						set()
  __snake_case:						List[str]			  =						word[0]
  for char in word[1:]:
    pairs.add((prev_char, char))
    __snake_case:						Optional[int]			  =						char
  return pairs







class    __snake_case	(							__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					VOCAB_FILES_NAMES
       lowerCAmelCase__						=					PRETRAINED_VOCAB_FILES_MAP
       lowerCAmelCase__						=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       lowerCAmelCase__						=					["""input_ids""", """attention_mask"""]




       def __init__(  self			:   List[str]							,    A			:   Dict							,    A			:   str							,    A			:   List[str]="replace"							,    A			:   Any="<s>"							,    A			:   List[Any]="</s>"							,    A			:   Union[str, Any]="</s>"							,    A			:   List[str]="<s>"							,    A			:   Optional[int]="<unk>"							,    A			:   Union[str, Any]="<pad>"							,    A			:   List[str]="<mask>"							,    A			:   Dict=False							,    **A			:   List[str]							,    ):
         __snake_case:						Optional[Any]			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else bos_token
         __snake_case:						int			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else eos_token
         __snake_case:						str			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else sep_token
         __snake_case:						Dict			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else cls_token
         __snake_case:						Optional[int]			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else unk_token
         __snake_case:						List[str]			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else pad_token

         # Mask token behave like a normal word, i.e. include the space before it
         __snake_case:						Any			  =						AddedToken(A							,    lstrip=A							,    rstrip=A		) if isinstance(A							,    A		) else mask_token

         super().__init__(
             errors=A							,    bos_token=A							,    eos_token=A							,    unk_token=A							,    sep_token=A							,    cls_token=A							,    pad_token=A							,    mask_token=A							,    add_prefix_space=A							,    **A							,    )

         with open(A							,    encoding="""utf-8"""		) as vocab_handle:
           __snake_case:						str			  =						json.load(A		)
         __snake_case:						int			  =						{v: k for k, v in self.encoder.items()}
         __snake_case:						Optional[Any]			  =						errors  # how to handle errors in decoding
         __snake_case:						str			  =						bytes_to_unicode()
         __snake_case:						Any			  =						{v: k for k, v in self.byte_encoder.items()}
         with open(A							,    encoding="""utf-8"""		) as merges_handle:
           __snake_case:						Dict			  =						merges_handle.read().split("""\n"""		)[1:-1]
         __snake_case:						Optional[int]			  =						[tuple(merge.split()		) for merge in bpe_merges]
         __snake_case:						List[str]			  =						dict(zip(A							,    range(len(A		)		)		)		)
         __snake_case:						str			  =						{}
         __snake_case:						int			  =						add_prefix_space

         # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
         __snake_case:						Optional[Any]			  =						re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""		)




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return len(self.encoder		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return dict(self.encoder							,    **self.added_tokens_encoder		)




       def 							UpperCAmelCase__			(  self			:   Tuple							,    A			:   Union[str, Any]		):
         if token in self.cache:
           return self.cache[token]
         __snake_case:						Any			  =						tuple(A		)
         __snake_case:						Optional[int]			  =						get_pairs(A		)

         if not pairs:
           return token

         while True:
           __snake_case:						List[str]			  =						min(A							,    key=lambda A		: self.bpe_ranks.get(A							,    float("""inf"""		)		)		)
           if bigram not in self.bpe_ranks:
             break
           __snake_case:						Any			  =						bigram
           __snake_case:						Optional[int]			  =						[]
           __snake_case:						Union[str, Any]			  =						0
           while i < len(A		):
             try:
               __snake_case:						Optional[int]			  =						word.index(A							,    A		)
             except ValueError:
               new_word.extend(word[i:]		)
               break
             else:
               new_word.extend(word[i:j]		)
               __snake_case:						Any			  =						j

             if word[i] == first and i < len(A		) - 1 and word[i + 1] == second:
               new_word.append(first + second		)
               i += 2
             else:
               new_word.append(word[i]		)
               i += 1
           __snake_case:						List[Any]			  =						tuple(A		)
           __snake_case:						Dict			  =						new_word
           if len(A		) == 1:
             break
           else:
             __snake_case:						List[str]			  =						get_pairs(A		)
         __snake_case:						Optional[int]			  =						""" """.join(A		)
         __snake_case:						List[Any]			  =						word
         return word




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   List[Any]		):
         __snake_case:						str			  =						[]
         for token in re.findall(self.pat							,    A		):
           __snake_case:						int			  =						"""""".join(
               self.byte_encoder[b] for b in token.encode("""utf-8"""		)		)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
           bpe_tokens.extend(bpe_token for bpe_token in self.bpe(A		).split(""" """		)		)
         return bpe_tokens




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   int		):
         return self.encoder.get(A							,    self.encoder.get(self.unk_token		)		)




       def 							UpperCAmelCase__			(  self			:   str							,    A			:   Any		):
         return self.decoder.get(A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]							,    A			:   str		):
         __snake_case:						Optional[Any]			  =						"""""".join(A		)
         __snake_case:						Any			  =						bytearray([self.byte_decoder[c] for c in text]		).decode("""utf-8"""							,    errors=self.errors		)
         return text




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   str							,    A			:   Optional[str] = None		):
         if not os.path.isdir(A		):
           logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''		)
           return
         __snake_case:						Any			  =						os.path.join(
             A							,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]		)
         __snake_case:						Optional[Any]			  =						os.path.join(
             A							,    (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]		)

         with open(A							,    """w"""							,    encoding="""utf-8"""		) as f:
           f.write(json.dumps(self.encoder							,    indent=2							,    sort_keys=A							,    ensure_ascii=A		) + """\n"""		)

         __snake_case:						Any			  =						0
         with open(A							,    """w"""							,    encoding="""utf-8"""		) as writer:
           writer.write("""#version: 0.2\n"""		)
           for bpe_tokens, token_index in sorted(self.bpe_ranks.items()							,    key=lambda A		: kv[1]		):
             if index != token_index:
               logger.warning(
                   f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
                   """ Please check that the tokenizer is not corrupted!"""		)
               __snake_case:						Union[str, Any]			  =						token_index
             writer.write(""" """.join(A		) + """\n"""		)
             index += 1

         return vocab_file, merge_file




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   List[int]							,    A			:   Optional[List[int]] = None		):
         if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         __snake_case:						Dict			  =						[self.cls_token_id]
         __snake_case:						Optional[int]			  =						[self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep




       def 							UpperCAmelCase__			(  self			:   List[str]							,    A			:   List[int]							,    A			:   Optional[List[int]] = None							,    A			:   bool = False		):
         if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=A							,    token_ids_a=A							,    already_has_special_tokens=A		)

         if token_ids_a is None:
           return [1] + ([0] * len(A		)) + [1]
         return [1] + ([0] * len(A		)) + [1, 1] + ([0] * len(A		)) + [1]




       def 							UpperCAmelCase__			(  self			:   Any							,    A			:   List[int]							,    A			:   Optional[List[int]] = None		):
         __snake_case:						Any			  =						[self.sep_token_id]
         __snake_case:						Union[str, Any]			  =						[self.cls_token_id]

         if token_ids_a is None:
           return len(cls + token_ids_a + sep		) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep		) * [0]






       def 							UpperCAmelCase__			(  self			:   int							,    A			:   str							,    A			:   str=False							,    **A			:   Optional[Any]		):
         __snake_case:						List[Any]			  =						kwargs.pop("""add_prefix_space"""							,    self.add_prefix_space		)
         if (is_split_into_words or add_prefix_space) and (len(A		) > 0 and not text[0].isspace()):
           __snake_case:						Any			  =						""" """ + text
         return (text, kwargs)













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    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						str			  =						[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetDownsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Union[str, Any]			  =						[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Union[str, Any]			  =						[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case  ,       __snake_case:						List[str]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						List[Any]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case  ,       __snake_case:						Union[str, Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[Any]			  =						32
         return init_dict, inputs_dict






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Optional[Any]			  =						[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Any		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Optional[Any]			  =						[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						str			  =						[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						str			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Optional[Any]			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Tuple			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Dict			  =						[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaD  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						{
             """in_channels""": 32,
             """temb_channels""": 128,
         }
         __snake_case:						List[str]			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Tuple			  =						[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						int			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						int			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDSimpleCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Tuple			  =						[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetUpsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						int			  =						[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[int]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						List[Any]			  =						[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A							,    include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Optional[Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Union[str, Any]			  =						[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   int		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Optional[Any]			  =						[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[int]			  =						[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Union[str, Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Dict			  =						[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Any			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						Any			  =						[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
         super().test_output(A		)






