



import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class  snake_case__						(	lowerCAmelCase_    ,					unittest.TestCase					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     KandinskyPriorPipeline
     _SCREAMING_SNAKE_CASE            =     ["""prompt"""]
     _SCREAMING_SNAKE_CASE            =     ["""prompt""", """negative_prompt"""]
     _SCREAMING_SNAKE_CASE            =     [
         """num_images_per_prompt""",
         """generator""",
         """num_inference_steps""",
         """latents""",
         """negative_prompt""",
         """guidance_scale""",
         """output_type""",
         """return_dict""",
     ]
     _SCREAMING_SNAKE_CASE            =     False






     @property
     def        lowercase_       (	self  :  List[Any] )       ->int:
            return 3_2






     @property
     def        lowercase_       (	self  :  int )       ->int:
            return 3_2






     @property
     def        lowercase_       (	self  :  Dict )       ->List[Any]:
            return self.time_input_dim






     @property
     def        lowercase_       (	self  :  Dict )       ->str:
            return self.time_input_dim * 4






     @property
     def        lowercase_       (	self  :  Dict )       ->Optional[Any]:
            return 1_0_0






     @property
     def        lowercase_       (	self  :  Optional[Any] )       ->Tuple:
            snake_case__							:     int            =     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )
            return tokenizer






     @property
     def        lowercase_       (	self  :  Optional[int] )       ->List[Any]:
            torch.manual_seed(0 )
            snake_case__							:     Tuple            =     CLIPTextConfig(
                bos_token_id=0,			eos_token_id=2,			hidden_size=self.text_embedder_hidden_size,			projection_dim=self.text_embedder_hidden_size,			intermediate_size=3_7,			layer_norm_eps=1e-05,			num_attention_heads=4,			num_hidden_layers=5,			pad_token_id=1,			vocab_size=1_0_0_0,			)
            return CLIPTextModelWithProjection(_snake_case )






     @property
     def        lowercase_       (	self  :  List[str] )       ->int:
            torch.manual_seed(0 )

            snake_case__							:     Any            =     {
                'num_attention_heads': 2,
                'attention_head_dim': 1_2,
                'embedding_dim': self.text_embedder_hidden_size,
                'num_layers': 1,
            }

            snake_case__							:     Tuple            =     PriorTransformer(**_snake_case )
            # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
            snake_case__							:     Optional[Any]            =     nn.Parameter(torch.ones(model.clip_std.shape ) )
            return model






     @property
     def        lowercase_       (	self  :  Any )       ->Optional[Any]:
            torch.manual_seed(0 )
            snake_case__							:     int            =     CLIPVisionConfig(
                hidden_size=self.text_embedder_hidden_size,			image_size=2_2_4,			projection_dim=self.text_embedder_hidden_size,			intermediate_size=3_7,			num_attention_heads=4,			num_channels=3,			num_hidden_layers=5,			patch_size=1_4,			)

            snake_case__							:     Tuple            =     CLIPVisionModelWithProjection(_snake_case )
            return model






     @property
     def        lowercase_       (	self  :  Optional[int] )       ->Tuple:
            snake_case__							:     Dict            =     CLIPImageProcessor(
                crop_size=2_2_4,			do_center_crop=_snake_case,			do_normalize=_snake_case,			do_resize=_snake_case,			image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],			image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],			resample=3,			size=2_2_4,			)

            return image_processor






     def        lowercase_       (	self  :  List[str] )       ->List[Any]:
            snake_case__							:     Dict            =     self.dummy_prior
            snake_case__							:     Optional[int]            =     self.dummy_image_encoder
            snake_case__							:     Optional[int]            =     self.dummy_text_encoder
            snake_case__							:     Tuple            =     self.dummy_tokenizer
            snake_case__							:     Tuple            =     self.dummy_image_processor

            snake_case__							:     str            =     UnCLIPScheduler(
                variance_type='fixed_small_log',			prediction_type='sample',			num_train_timesteps=1_0_0_0,			clip_sample=_snake_case,			clip_sample_range=1_0.0,			)

            snake_case__							:     Optional[Any]            =     {
                'prior': prior,
                'image_encoder': image_encoder,
                'text_encoder': text_encoder,
                'tokenizer': tokenizer,
                'scheduler': scheduler,
                'image_processor': image_processor,
            }

            return components






     def        lowercase_       (	self  :  List[str],			_snake_case  :  Optional[Any],			_snake_case  :  List[Any]=0 )       ->Tuple:
            if str(_snake_case ).startswith('mps' ):
                   snake_case__							:     List[str]            =     torch.manual_seed(_snake_case )
            else:
                   snake_case__							:     int            =     torch.Generator(device=_snake_case ).manual_seed(_snake_case )
            snake_case__							:     str            =     {
                'prompt': 'horse',
                'generator': generator,
                'guidance_scale': 4.0,
                'num_inference_steps': 2,
                'output_type': 'np',
            }
            return inputs






     def        lowercase_       (	self  :  str )       ->Optional[int]:
            snake_case__							:     int            =     'cpu'

            snake_case__							:     Dict            =     self.get_dummy_components()

            snake_case__							:     Optional[int]            =     self.pipeline_class(**_snake_case )
            snake_case__							:     Optional[int]            =     pipe.to(_snake_case )

            pipe.set_progress_bar_config(disable=_snake_case )

            snake_case__							:     Optional[int]            =     pipe(**self.get_dummy_inputs(_snake_case ) )
            snake_case__							:     Optional[Any]            =     output.image_embeds

            snake_case__							:     Any            =     pipe(
                **self.get_dummy_inputs(_snake_case ),			return_dict=_snake_case,			)[0]

            snake_case__							:     Any            =     image[0, -1_0:]
            snake_case__							:     Union[str, Any]            =     image_from_tuple[0, -1_0:]

            assert image.shape == (1, 3_2)

            snake_case__							:     Tuple            =     np.array(
                [-0.0_5_3_2, 1.7_1_2_0, 0.3_6_5_6, -1.0_8_5_2, -0.8_9_4_6, -1.1_7_5_6, 0.4_3_4_8, 0.2_4_8_2, 0.5_1_4_6, -0.1_1_5_6] )

            assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
            assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2






     @skip_mps
     def        lowercase_       (	self  :  str )       ->List[str]:
            snake_case__							:     Any            =     torch_device == 'cpu'
            snake_case__							:     Any            =     True
            snake_case__							:     Optional[int]            =     False

            self._test_inference_batch_single_identical(
                test_max_difference=_snake_case,			relax_max_difference=_snake_case,			test_mean_pixel_difference=_snake_case,			)






     @skip_mps
     def        lowercase_       (	self  :  Optional[int] )       ->List[Any]:
            snake_case__							:     Dict            =     torch_device == 'cpu'
            snake_case__							:     Dict            =     False

            self._test_attention_slicing_forward_pass(
                test_max_difference=_snake_case,			test_mean_pixel_difference=_snake_case,			)











import json
import os
import re
import unicodedata
from typing import Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer, _is_control, _is_punctuation, _is_whitespace
from ...utils import logging


a_       :Tuple				  =				logging.get_logger(__name__)

a_       :Dict				  =				{
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

a_       :List[str]				  =				{
    "vocab_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/vocab.json"},
    "merges_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/merges.txt"},
}

a_       :Union[str, Any]				  =				{
    "openai-gpt": 512,
}
def 	lowercase_							(A			:			Dict				):
       snake_case__							:     Optional[int]            =     text.strip()
       if not text:
              return []
       snake_case__							:     List[str]            =     text.split()
       return tokens




class  snake_case__						(	lowerCAmelCase_					):






     """simple docstring"""


     def __init__(	self  :  List[Any],			_snake_case  :  Any=True,			_snake_case  :  Optional[Any]=None,			_snake_case  :  Dict=True,			_snake_case  :  List[str]=None,			_snake_case  :  List[Any]=True,			)       ->Any:
            if never_split is None:
                   snake_case__							:     int            =     []
            snake_case__							:     Any            =     do_lower_case
            snake_case__							:     Union[str, Any]            =     set(_snake_case )
            snake_case__							:     Union[str, Any]            =     tokenize_chinese_chars
            snake_case__							:     str            =     strip_accents
            snake_case__							:     Optional[Any]            =     do_split_on_punc






     def        lowercase_       (	self  :  Dict,			_snake_case  :  Optional[int],			_snake_case  :  List[Any]=None )       ->List[str]:
            snake_case__							:     Tuple            =     self.never_split.union(set(_snake_case ) ) if never_split else self.never_split
            snake_case__							:     Optional[int]            =     self._clean_text(_snake_case )

            # This was added on November 1st, 2018 for the multilingual and Chinese
            # models. This is also applied to the English models now, but it doesn't
            # matter since the English models were not trained on any Chinese data
            # and generally don't have any Chinese data in them (there are Chinese
            # characters in the vocabulary because Wikipedia does have some Chinese
            # words in the English Wikipedia.).
            if self.tokenize_chinese_chars:
                   snake_case__							:     List[str]            =     self._tokenize_chinese_chars(_snake_case )
            # prevents treating the same character with different unicode codepoints as different characters
            snake_case__							:     Optional[int]            =     unicodedata.normalize('NFC',			_snake_case )
            snake_case__							:     str            =     whitespace_tokenize(_snake_case )
            snake_case__							:     Optional[Any]            =     []
            for token in orig_tokens:
                   if token not in never_split:
                          if self.do_lower_case:
                                 snake_case__							:     int            =     token.lower()
                                 if self.strip_accents is not False:
                                        snake_case__							:     Any            =     self._run_strip_accents(_snake_case )
                          elif self.strip_accents:
                                 snake_case__							:     Optional[Any]            =     self._run_strip_accents(_snake_case )
                   split_tokens.extend(self._run_split_on_punc(_snake_case,			_snake_case ) )

            snake_case__							:     Dict            =     whitespace_tokenize(' '.join(_snake_case ) )
            return output_tokens






     def        lowercase_       (	self  :  int,			_snake_case  :  List[str] )       ->int:
            snake_case__							:     Dict            =     unicodedata.normalize('NFD',			_snake_case )
            snake_case__							:     Dict            =     []
            for char in text:
                   snake_case__							:     List[Any]            =     unicodedata.category(_snake_case )
                   if cat == "Mn":
                          continue
                   output.append(_snake_case )
            return "".join(_snake_case )






     def        lowercase_       (	self  :  str,			_snake_case  :  Dict,			_snake_case  :  Optional[int]=None )       ->Dict:
            if not self.do_split_on_punc or (never_split is not None and text in never_split):
                   return [text]
            snake_case__							:     Dict            =     list(_snake_case )
            snake_case__							:     List[str]            =     0
            snake_case__							:     Union[str, Any]            =     True
            snake_case__							:     Tuple            =     []
            while i < len(_snake_case ):
                   snake_case__							:     Any            =     chars[i]
                   if _is_punctuation(_snake_case ):
                          output.append([char] )
                          snake_case__							:     int            =     True
                   else:
                          if start_new_word:
                                 output.append([] )
                          snake_case__							:     Union[str, Any]            =     False
                          output[-1].append(_snake_case )
                   i += 1

            return ["".join(_snake_case ) for x in output]






     def        lowercase_       (	self  :  Any,			_snake_case  :  int )       ->Any:
            snake_case__							:     Dict            =     []
            for char in text:
                   snake_case__							:     Union[str, Any]            =     ord(_snake_case )
                   if self._is_chinese_char(_snake_case ):
                          output.append(' ' )
                          output.append(_snake_case )
                          output.append(' ' )
                   else:
                          output.append(_snake_case )
            return "".join(_snake_case )






     def        lowercase_       (	self  :  Any,			_snake_case  :  List[str] )       ->Dict:
            # This defines a "chinese character" as anything in the CJK Unicode block:
            #   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
            #
            # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
            # despite its name. The modern Korean Hangul alphabet is a different block,
            # as is Japanese Hiragana and Katakana. Those alphabets are used to write
            # space-separated words, so they are not treated specially and handled
            # like the all of the other languages.
            if (
                (cp >= 0X4_E_0_0 and cp <= 0X9_F_F_F)
                or (cp >= 0X3_4_0_0 and cp <= 0X4_D_B_F)  #
                or (cp >= 0X2_0_0_0_0 and cp <= 0X2_A_6_D_F)  #
                or (cp >= 0X2_A_7_0_0 and cp <= 0X2_B_7_3_F)  #
                or (cp >= 0X2_B_7_4_0 and cp <= 0X2_B_8_1_F)  #
                or (cp >= 0X2_B_8_2_0 and cp <= 0X2_C_E_A_F)  #
                or (cp >= 0XF_9_0_0 and cp <= 0XF_A_F_F)
                or (cp >= 0X2_F_8_0_0 and cp <= 0X2_F_A_1_F)  #
            ):  #
                   return True

            return False






     def        lowercase_       (	self  :  List[str],			_snake_case  :  str )       ->Any:
            snake_case__							:     Optional[int]            =     []
            for char in text:
                   snake_case__							:     Any            =     ord(_snake_case )
                   if cp == 0 or cp == 0XF_F_F_D or _is_control(_snake_case ):
                          continue
                   if _is_whitespace(_snake_case ):
                          output.append(' ' )
                   else:
                          output.append(_snake_case )
            return "".join(_snake_case )


def 	lowercase_							(A			:			Dict				):
       snake_case__							:     Dict            =     set()
       snake_case__							:     List[str]            =     word[0]
       for char in word[1:]:
              pairs.add((prev_char, char)				)
              snake_case__							:     str            =     char
       return pairs
def 	lowercase_							(A			:			int				):
       snake_case__							:     Union[str, Any]            =     text.replace('—'		, '-'				)
       snake_case__							:     List[str]            =     text.replace('–'		, '-'				)
       snake_case__							:     List[str]            =     text.replace('―'		, '-'				)
       snake_case__							:     Any            =     text.replace('…'		, '...'				)
       snake_case__							:     Union[str, Any]            =     text.replace('´'		, '\''				)
       snake_case__							:     str            =     re.sub(r'(-+|~+|!+|"+|;+|\?+|\++|,+|\)+|\(+|\\+|\/+|\*+|\[+|\]+|}+|{+|\|+|_+)'		, r' \1 '		, A				)
       snake_case__							:     int            =     re.sub(r'\s*\n\s*'		, ' \n '		, A				)
       snake_case__							:     Dict            =     re.sub(r'[^\S\n]+'		, ' '		, A				)
       return text.strip()





class  snake_case__						(	lowerCAmelCase_					):






     """simple docstring"""


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






     def __init__(	self  :  Optional[Any],			_snake_case  :  Union[str, Any],			_snake_case  :  Tuple,			_snake_case  :  Optional[int]="<unk>",			**_snake_case  :  int )       ->Optional[Any]:
            super().__init__(unk_token=_snake_case,			**_snake_case )

            try:
                   import ftfy
                   from spacy.lang.en import English

                   snake_case__							:     List[Any]            =     English()
                   snake_case__							:     List[Any]            =     _nlp.tokenizer
                   snake_case__							:     List[Any]            =     ftfy.fix_text
            except ImportError:
                   logger.warning('ftfy or spacy is not installed using BERT BasicTokenizer instead of SpaCy & ftfy.' )
                   snake_case__							:     Union[str, Any]            =     BasicTokenizer(do_lower_case=_snake_case )
                   snake_case__							:     Optional[int]            =     None

            with open(_snake_case,			encoding='utf-8' ) as vocab_handle:
                   snake_case__							:     Union[str, Any]            =     json.load(_snake_case )
            snake_case__							:     List[str]            =     {v: k for k, v in self.encoder.items()}
            with open(_snake_case,			encoding='utf-8' ) as merges_handle:
                   snake_case__							:     int            =     merges_handle.read().split('\n' )[1:-1]
            snake_case__							:     Dict            =     [tuple(merge.split() ) for merge in merges]
            snake_case__							:     Optional[Any]            =     dict(zip(_snake_case,			range(len(_snake_case ) ) ) )
            snake_case__							:     int            =     {}






     @property
     def        lowercase_       (	self  :  Any )       ->str:
            return True






     @property
     def        lowercase_       (	self  :  Dict )       ->str:
            return len(self.encoder )






     def        lowercase_       (	self  :  Dict )       ->Optional[int]:
            return dict(self.encoder,			**self.added_tokens_encoder )






     def        lowercase_       (	self  :  List[Any],			_snake_case  :  Union[str, Any] )       ->Any:
            snake_case__							:     Tuple            =     tuple(token[:-1] ) + (token[-1] + '</w>',)
            if token in self.cache:
                   return self.cache[token]
            snake_case__							:     List[Any]            =     get_pairs(_snake_case )

            if not pairs:
                   return token + "</w>"

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

                          if word[i] == first and i < len(_snake_case ) - 1 and word[i + 1] == second:
                                 new_word.append(first + second )
                                 i += 2
                          else:
                                 new_word.append(word[i] )
                                 i += 1
                   snake_case__							:     Optional[int]            =     tuple(_snake_case )
                   snake_case__							:     Union[str, Any]            =     new_word
                   if len(_snake_case ) == 1:
                          break
                   else:
                          snake_case__							:     List[Any]            =     get_pairs(_snake_case )
            snake_case__							:     List[Any]            =     ' '.join(_snake_case )
            if word == "\n  </w>":
                   snake_case__							:     Any            =     '\n</w>'
            snake_case__							:     Optional[int]            =     word
            return word






     def        lowercase_       (	self  :  Union[str, Any],			_snake_case  :  Optional[int] )       ->Dict:
            snake_case__							:     Optional[Any]            =     []
            if self.fix_text is None:
                   # Using BERT's BasicTokenizer
                   snake_case__							:     List[str]            =     self.nlp.tokenize(_snake_case )
                   for token in text:
                          split_tokens.extend(list(self.bpe(_snake_case ).split(' ' ) ) )
            else:
                   # Using SpaCy & ftfy (original tokenization process of OpenAI GPT)
                   snake_case__							:     Optional[Any]            =     self.nlp(text_standardize(self.fix_text(_snake_case ) ) )
                   for token in text:
                          split_tokens.extend(list(self.bpe(token.text.lower() ).split(' ' ) ) )
            return split_tokens






     def        lowercase_       (	self  :  Tuple,			_snake_case  :  Union[str, Any] )       ->List[Any]:
            return self.encoder.get(_snake_case,			self.encoder.get(self.unk_token ) )






     def        lowercase_       (	self  :  Tuple,			_snake_case  :  Dict )       ->Any:
            return self.decoder.get(_snake_case,			self.unk_token )






     def        lowercase_       (	self  :  str,			_snake_case  :  List[Any] )       ->List[Any]:
            snake_case__							:     Dict            =     ''.join(_snake_case ).replace('</w>',			' ' ).strip()
            return out_string






     def        lowercase_       (	self  :  Dict,			_snake_case  :  str,			_snake_case  :  Optional[str] = None )       ->Tuple[str]:
            if not os.path.isdir(_snake_case ):
                   logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' )
                   return
            snake_case__							:     Union[str, Any]            =     os.path.join(
                _snake_case,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] )
            snake_case__							:     List[Any]            =     os.path.join(
                _snake_case,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'] )

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

            snake_case__							:     Union[str, Any]            =     0
            with open(_snake_case,			'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 _snake_case : 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__							:     Dict            =     token_index
                          writer.write(' '.join(_snake_case ) + '\n' )
                          index += 1

            return vocab_file, merge_file






