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     a__( lowerCAmelCase__			,						unittest.TestCase     ):


			'''simple docstring'''






			UpperCAmelCase_      :					int								=	KandinskyPriorPipeline
			UpperCAmelCase_      :					Optional[int]								=	['''prompt''']
			UpperCAmelCase_      :					Optional[Any]								=	['''prompt''', '''negative_prompt''']
			UpperCAmelCase_      :					List[Any]								=	[
			    '''num_images_per_prompt''',
			    '''generator''',
			    '''num_inference_steps''',
			    '''latents''',
			    '''negative_prompt''',
			    '''guidance_scale''',
			    '''output_type''',
			    '''return_dict''',
			]
			UpperCAmelCase_      :					List[str]								=	False



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 32



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 32



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return self.time_input_dim



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return self.time_input_dim * 4



			@property
			def 							a_	(       self):




					"""simple docstring"""


					return 100



			@property
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")
					return tokenizer



			@property
			def 							a_	(       self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase        =  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=37	,   layer_norm_eps=1E-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1000	,   )
					return CLIPTextModelWithProjection(__lowerCAmelCase)



			@property
			def 							a_	(       self):




					"""simple docstring"""


					torch.manual_seed(0)

					lowerCAmelCase        =  {
					    """num_attention_heads""": 2,
					    """attention_head_dim""": 12,
					    """embedding_dim""": self.text_embedder_hidden_size,
					    """num_layers""": 1,
					}

					lowerCAmelCase        =  PriorTransformer(**__lowerCAmelCase)
					# 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
					lowerCAmelCase        =  nn.Parameter(torch.ones(model.clip_std.shape))
					return model



			@property
			def 							a_	(       self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase        =  CLIPVisionConfig(
					    hidden_size=self.text_embedder_hidden_size	,   image_size=224	,   projection_dim=self.text_embedder_hidden_size	,   intermediate_size=37	,   num_attention_heads=4	,   num_channels=3	,   num_hidden_layers=5	,   patch_size=14	,   )

					lowerCAmelCase        =  CLIPVisionModelWithProjection(__lowerCAmelCase)
					return model



			@property
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  CLIPImageProcessor(
					    crop_size=224	,   do_center_crop=__lowerCAmelCase	,   do_normalize=__lowerCAmelCase	,   do_resize=__lowerCAmelCase	,   image_mean=[0.48145466, 0.4578275, 0.40821073]	,   image_std=[0.26862954, 0.26130258, 0.27577711]	,   resample=3	,   size=224	,   )

					return image_processor



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  self.dummy_prior
					lowerCAmelCase        =  self.dummy_image_encoder
					lowerCAmelCase        =  self.dummy_text_encoder
					lowerCAmelCase        =  self.dummy_tokenizer
					lowerCAmelCase        =  self.dummy_image_processor

					lowerCAmelCase        =  UnCLIPScheduler(
					    variance_type="""fixed_small_log"""	,   prediction_type="""sample"""	,   num_train_timesteps=1000	,   clip_sample=__lowerCAmelCase	,   clip_sample_range=10.0	,   )

					lowerCAmelCase        =  {
					    """prior""": prior,
					    """image_encoder""": image_encoder,
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """scheduler""": scheduler,
					    """image_processor""": image_processor,
					}

					return components



			def 							a_	(       self	,   __lowerCAmelCase	,   __lowerCAmelCase=0):




					"""simple docstring"""


					if str(__lowerCAmelCase).startswith("""mps"""):
							lowerCAmelCase        =  torch.manual_seed(__lowerCAmelCase)
					else:
							lowerCAmelCase        =  torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
					lowerCAmelCase        =  {
					    """prompt""": """horse""",
					    """generator""": generator,
					    """guidance_scale""": 4.0,
					    """num_inference_steps""": 2,
					    """output_type""": """np""",
					}
					return inputs



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  """cpu"""

					lowerCAmelCase        =  self.get_dummy_components()

					lowerCAmelCase        =  self.pipeline_class(**__lowerCAmelCase)
					lowerCAmelCase        =  pipe.to(__lowerCAmelCase)

					pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase        =  pipe(**self.get_dummy_inputs(__lowerCAmelCase))
					lowerCAmelCase        =  output.image_embeds

					lowerCAmelCase        =  pipe(
					    **self.get_dummy_inputs(__lowerCAmelCase)	,   return_dict=__lowerCAmelCase	,   )[0]

					lowerCAmelCase        =  image[0, -10:]
					lowerCAmelCase        =  image_from_tuple[0, -10:]

					assert image.shape == (1, 32)

					lowerCAmelCase        =  np.array(
					    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156])

					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 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  torch_device == """cpu"""
					lowerCAmelCase        =  True
					lowerCAmelCase        =  False

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







			@skip_mps
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  torch_device == """cpu"""
					lowerCAmelCase        =  False

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





'''simple docstring'''




import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
						from tokenizers import Tokenizer
						from tokenizers.models import WordPiece






class     a__( unittest.TestCase     ):


			'''simple docstring'''






			def 							a_	(       self	,   __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase        =  list(tokenizer_class.max_model_input_sizes.keys())
					for model_name in sa_models[:1]:
							lowerCAmelCase        =  tokenizer_class.from_pretrained(__lowerCAmelCase)
							self.assertIsNotNone(__lowerCAmelCase)
							self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)
							self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)

							for special_tok in tokenizer.all_special_tokens:
									self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)
									lowerCAmelCase        =  tokenizer.convert_tokens_to_ids(__lowerCAmelCase)
									self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)



			def 							a_	(       self	,   __lowerCAmelCase	,   __lowerCAmelCase = None):




					"""simple docstring"""


					lowerCAmelCase        =  pickle.dumps(__lowerCAmelCase)
					self.assertIsNotNone(__lowerCAmelCase)

					lowerCAmelCase        =  pickle.loads(__lowerCAmelCase)

					# Ensure is_fast is correctly restored
					self.assertEqual(be_restored.is_fast	,   be_original.is_fast)

					# Ensure encodings are potentially correctly restored
					if be_original.is_fast:
							self.assertIsNotNone(be_restored.encodings)
					else:
							self.assertIsNone(be_restored.encodings)

					# Ensure the keys are the same
					for original_v, restored_v in zip(be_original.values()	,   be_restored.values()):
							if equal_op:
									self.assertTrue(equal_op(__lowerCAmelCase	,   __lowerCAmelCase))
							else:
									self.assertEqual(__lowerCAmelCase	,   __lowerCAmelCase)



			@slow
			def 							a_	(       self):




					"""simple docstring"""


					self.check_tokenizer_from_pretrained(__lowerCAmelCase)



			def 							a_	(       self):




					"""simple docstring"""


					self.assertEqual(TensorType("""tf""")	,   TensorType.TENSORFLOW)
					self.assertEqual(TensorType("""pt""")	,   TensorType.PYTORCH)
					self.assertEqual(TensorType("""np""")	,   TensorType.NUMPY)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import numpy as np

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					# Python no tensor
					with self.subTest("""BatchEncoding (Python, return_tensors=None)"""):
							self.assert_dump_and_restore(tokenizer_p("""Small example to encode"""))

					with self.subTest("""BatchEncoding (Python, return_tensors=NUMPY)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.NUMPY)	,   np.array_equal)

					with self.subTest("""BatchEncoding (Rust, return_tensors=None)"""):
							self.assert_dump_and_restore(tokenizer_r("""Small example to encode"""))

					with self.subTest("""BatchEncoding (Rust, return_tensors=NUMPY)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.NUMPY)	,   np.array_equal)



			@require_tf
			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import tensorflow as tf

					def tf_array_equals(__lowerCAmelCase	,   __lowerCAmelCase):
							return tf.reduce_all(tf.equal(__lowerCAmelCase	,   __lowerCAmelCase))

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""BatchEncoding (Python, return_tensors=TENSORFLOW)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.TENSORFLOW)	,   __lowerCAmelCase)

					with self.subTest("""BatchEncoding (Rust, return_tensors=TENSORFLOW)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.TENSORFLOW)	,   __lowerCAmelCase)



			@require_torch
			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import torch

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""BatchEncoding (Python, return_tensors=PYTORCH)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.PYTORCH)	,   torch.equal)

					with self.subTest("""BatchEncoding (Rust, return_tensors=PYTORCH)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.PYTORCH)	,   torch.equal)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""Python Tokenizer"""):
							self.assertFalse(tokenizer_p("""Small example to_encode""").is_fast)

					with self.subTest("""Rust Tokenizer"""):
							self.assertTrue(tokenizer_r("""Small example to_encode""").is_fast)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  tokenizer_r(["""Test""", """\xad""", """test"""]	,   is_split_into_words=__lowerCAmelCase)

					self.assertEqual(encoded.word_to_tokens(0)	,   TokenSpan(start=1	,   end=2))
					self.assertEqual(encoded.word_to_tokens(1)	,   __lowerCAmelCase)
					self.assertEqual(encoded.word_to_tokens(2)	,   TokenSpan(start=2	,   end=3))



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_torch
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_tf
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_flax
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  [{"""input_ids""": np.array([0, 1, 2])}, {"""input_ids""": np.array([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   np.ndarray))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""np""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   np.ndarray))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_torch
			def 							a_	(       self):




					"""simple docstring"""


					import torch

					lowerCAmelCase        =  [{"""input_ids""": torch.tensor([0, 1, 2])}, {"""input_ids""": torch.tensor([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   torch.Tensor))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""pt""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   torch.Tensor))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_tf
			def 							a_	(       self):




					"""simple docstring"""


					import tensorflow as tf

					lowerCAmelCase        =  [{"""input_ids""": tf.constant([0, 1, 2])}, {"""input_ids""": tf.constant([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   tf.Tensor))
					self.assertEqual(batch["""input_ids"""].numpy().tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""tf""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   tf.Tensor))
					self.assertEqual(batch["""input_ids"""].numpy().tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  Tokenizer(WordPiece(unk_token="""[UNK]"""))
					PreTrainedTokenizerFast(tokenizer_object=__lowerCAmelCase)







			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  Tokenizer(WordPiece(unk_token="""[UNK]"""))
					with tempfile.TemporaryDirectory() as tmpdirname:
							bert_tokenizer.save(os.path.join(__lowerCAmelCase	,   """tokenizer.json"""))
							PreTrainedTokenizerFast(tokenizer_file=os.path.join(__lowerCAmelCase	,   """tokenizer.json"""))




