
"""simple docstring"""






import random
import unittest

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

from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import floats_tensor, 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       (     A__							,       unittest.TestCase		):
   a_					:		List[Any]     					=     KandinskyVaaPriorEmbaEmbPipeline
   a_					:		Dict     					=     ["""prompt""", """image"""]
   a_					:		Optional[Any]     					=     ["""prompt""", """image"""]
   a_					:		Optional[int]     					=     [
       """num_images_per_prompt""",
       """strength""",
       """generator""",
       """num_inference_steps""",
       """latents""",
       """negative_prompt""",
       """guidance_scale""",
       """output_type""",
       """return_dict""",
   ]
   a_					:		Union[str, Any]     					=     False







   @property
   def    UpperCAmelCase__	( self)   ->List[Any]:
      return 32







   @property
   def    UpperCAmelCase__	( self)   ->Dict:
      return 32







   @property
   def    UpperCAmelCase__	( self)   ->Union[str, Any]:
      return self.time_input_dim







   @property
   def    UpperCAmelCase__	( self)   ->Any:
      return self.time_input_dim * 4







   @property
   def    UpperCAmelCase__	( self)   ->List[str]:
      return 1_00







   @property
   def    UpperCAmelCase__	( self)   ->Tuple:
      a_						   =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
      return tokenizer







   @property
   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      torch.manual_seed(0)
      a_						   =     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-05       ,							num_attention_heads=4       ,							num_hidden_layers=5       ,							pad_token_id=1       ,							vocab_size=10_00       ,							)
      return CLIPTextModelWithProjection(_lowerCAmelCase)







   @property
   def    UpperCAmelCase__	( self)   ->List[Any]:
      torch.manual_seed(0)

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

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







   @property
   def    UpperCAmelCase__	( self)   ->List[str]:
      torch.manual_seed(0)
      a_						   =     CLIPVisionConfig(
          hidden_size=self.text_embedder_hidden_size       ,							image_size=2_24       ,							projection_dim=self.text_embedder_hidden_size       ,							intermediate_size=37       ,							num_attention_heads=4       ,							num_channels=3       ,							num_hidden_layers=5       ,							patch_size=14       ,							)

      a_						   =     CLIPVisionModelWithProjection(_lowerCAmelCase)
      return model







   @property
   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      a_						   =     CLIPImageProcessor(
          crop_size=2_24       ,							do_center_crop=_lowerCAmelCase       ,							do_normalize=_lowerCAmelCase       ,							do_resize=_lowerCAmelCase       ,							image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073]       ,							image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711]       ,							resample=3       ,							size=2_24       ,							)

      return image_processor







   def    UpperCAmelCase__	( self)   ->Union[str, Any]:
      a_						   =     self.dummy_prior
      a_						   =     self.dummy_image_encoder
      a_						   =     self.dummy_text_encoder
      a_						   =     self.dummy_tokenizer
      a_						   =     self.dummy_image_processor

      a_						   =     UnCLIPScheduler(
          variance_type="fixed_small_log"       ,							prediction_type="sample"       ,							num_train_timesteps=10_00       ,							clip_sample=_lowerCAmelCase       ,							clip_sample_range=10.0       ,							)

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

      return components







   def    UpperCAmelCase__	( self       ,							__UpperCAmelCase       ,							__UpperCAmelCase=0)   ->List[str]:
      if str(_lowerCAmelCase).startswith("mps"):
         a_						   =     torch.manual_seed(_lowerCAmelCase)
      else:
         a_						   =     torch.Generator(device=_lowerCAmelCase).manual_seed(_lowerCAmelCase)

      a_						   =     floats_tensor((1, 3, 64, 64)       ,							rng=random.Random(_lowerCAmelCase)).to(_lowerCAmelCase)
      a_						   =     image.cpu().permute(0       ,							2       ,							3       ,							1)[0]
      a_						   =     Image.fromarray(np.uinta(_lowerCAmelCase)).convert("RGB").resize((2_56, 2_56))

      a_						   =     {
          "prompt": "horse",
          "image": init_image,
          "strength": 0.5,
          "generator": generator,
          "guidance_scale": 4.0,
          "num_inference_steps": 2,
          "output_type": "np",
      }
      return inputs







   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      a_						   =     "cpu"

      a_						   =     self.get_dummy_components()

      a_						   =     self.pipeline_class(**_lowerCAmelCase)
      a_						   =     pipe.to(_lowerCAmelCase)

      pipe.set_progress_bar_config(disable=_lowerCAmelCase)

      a_						   =     pipe(**self.get_dummy_inputs(_lowerCAmelCase))
      a_						   =     output.image_embeds

      a_						   =     pipe(
          **self.get_dummy_inputs(_lowerCAmelCase)       ,							return_dict=_lowerCAmelCase       ,							)[0]

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

      assert image.shape == (1, 32)

      a_						   =     np.array(
          [
              0.1_071_284,
              1.3_330_271,
              0.61_260_223,
              -0.6_691_065,
              -0.3_846_852,
              -1.0_303_661,
              0.22_716_111,
              0.03_348_901,
              0.30_040_675,
              -0.24_805_029,
          ])

      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    UpperCAmelCase__	( self)   ->List[Any]:
      a_						   =     torch_device == "cpu"
      a_						   =     True
      a_						   =     False

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







   @skip_mps
   def    UpperCAmelCase__	( self)   ->Union[str, Any]:
      a_						   =     torch_device == "cpu"
      a_						   =     False

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






'''simple docstring'''


from typing import TYPE_CHECKING

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


_lowerCamelCase					:						Dict					     =							{
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCamelCase					:						List[str]					     =							[
				    'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DonutSwinModel',
				    'DonutSwinPreTrainedModel',
				]

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCamelCase					:						Any					     =							['DonutFeatureExtractor']
				_lowerCamelCase					:						Union[str, Any]					     =							['DonutImageProcessor']


if TYPE_CHECKING:
				from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
				from .processing_donut import DonutProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_donut_swin import (
								    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DonutSwinModel,
								    DonutSwinPreTrainedModel,
								)

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_donut import DonutFeatureExtractor
								from .image_processing_donut import DonutImageProcessor

else:
				import sys

				_lowerCamelCase					:						Optional[int]					     =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

