





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 						UpperCamelCase__					( lowerCAmelCase_				, unittest.TestCase  ):



     '''simple docstring'''

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






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						str:




           '''simple docstring'''


           return 32






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						List[Any]:




           '''simple docstring'''


           return 32






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						List[Any]:




           '''simple docstring'''


           return self.time_input_dim






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						Optional[int]:




           '''simple docstring'''


           return self.time_input_dim * 4






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						int:




           '''simple docstring'''


           return 100






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Optional[int]:




           '''simple docstring'''


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






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						Optional[Any]:




           '''simple docstring'''


           torch.manual_seed(0			)
           SCREAMING_SNAKE_CASE						=		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 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Optional[int]:




           '''simple docstring'''


           torch.manual_seed(0			)

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

           SCREAMING_SNAKE_CASE						=		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
           SCREAMING_SNAKE_CASE						=		nn.Parameter(torch.ones(model.clip_std.shape			)			)
           return model






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Optional[Any]:




           '''simple docstring'''


           torch.manual_seed(0			)
           SCREAMING_SNAKE_CASE						=		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		,)

           SCREAMING_SNAKE_CASE						=		CLIPVisionModelWithProjection(lowerCamelCase__			)
           return model






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		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 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Optional[Any]:




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE						=		UnCLIPScheduler(
               variance_type="""fixed_small_log"""		,prediction_type="""sample"""		,num_train_timesteps=1000		,clip_sample=lowerCamelCase__		,clip_sample_range=10.0		,)

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

           return components






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any		,lowerCamelCase__		:       Dict		,lowerCamelCase__		:       Optional[Any]=0			)	->						Optional[int]:




           '''simple docstring'''


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






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		"""cpu"""

           SCREAMING_SNAKE_CASE						=		self.get_dummy_components()

           SCREAMING_SNAKE_CASE						=		self.pipeline_class(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		pipe.to(lowerCamelCase__			)

           pipe.set_progress_bar_config(disable=lowerCamelCase__			)

           SCREAMING_SNAKE_CASE						=		pipe(**self.get_dummy_inputs(lowerCamelCase__			)			)
           SCREAMING_SNAKE_CASE						=		output.image_embeds

           SCREAMING_SNAKE_CASE						=		pipe(
               **self.get_dummy_inputs(lowerCamelCase__			)		,return_dict=lowerCamelCase__		,)[0]

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

           assert image.shape == (1, 32)

           SCREAMING_SNAKE_CASE						=		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 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		torch_device == """cpu"""
           SCREAMING_SNAKE_CASE						=		True
           SCREAMING_SNAKE_CASE						=		False

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






     @skip_mps
     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		torch_device == """cpu"""
           SCREAMING_SNAKE_CASE						=		False

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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE_		  =			{
    """configuration_markuplm""": ["""MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MarkupLMConfig"""],
    """feature_extraction_markuplm""": ["""MarkupLMFeatureExtractor"""],
    """processing_markuplm""": ["""MarkupLMProcessor"""],
    """tokenization_markuplm""": ["""MarkupLMTokenizer"""],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_		  =			["""MarkupLMTokenizerFast"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_		  =			[
          """MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """MarkupLMForQuestionAnswering""",
          """MarkupLMForSequenceClassification""",
          """MarkupLMForTokenClassification""",
          """MarkupLMModel""",
          """MarkupLMPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_markuplm import MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP, MarkupLMConfig
      from .feature_extraction_markuplm import MarkupLMFeatureExtractor
      from .processing_markuplm import MarkupLMProcessor
      from .tokenization_markuplm import MarkupLMTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_markuplm_fast import MarkupLMTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_markuplm import (
                MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST,
                MarkupLMForQuestionAnswering,
                MarkupLMForSequenceClassification,
                MarkupLMForTokenClassification,
                MarkupLMModel,
                MarkupLMPreTrainedModel,
            )


else:
      import sys

      SCREAMING_SNAKE_CASE_		  =			_LazyModule(__name__, globals()["""__file__"""], _import_structure)


