



"""simple docstring"""


import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()







class       A_			(     SCREAMING_SNAKE_CASE_	,   unittest.TestCase				):



						"""simple docstring"""
						__UpperCamelCase						=							KandinskyVaaControlnetPipeline
						__UpperCamelCase						=							["""image_embeds""", """negative_image_embeds""", """hint"""]
						__UpperCamelCase						=							["""image_embeds""", """negative_image_embeds""", """hint"""]
						__UpperCamelCase						=							[
						    """generator""",
						    """height""",
						    """width""",
						    """latents""",
						    """guidance_scale""",
						    """num_inference_steps""",
						    """return_dict""",
						    """guidance_scale""",
						    """num_images_per_prompt""",
						    """output_type""",
						    """return_dict""",
						]
						__UpperCamelCase						=							False






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






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






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






						@property
						def 	UpperCAmelCase__     (					self :int					)				->			List[str]:
												return self.time_input_dim * 4






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






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

												UpperCAmelCase             = {
												    'in_channels': 8,
												    # Out channels is double in channels because predicts mean and variance
												    'out_channels': 8,
												    'addition_embed_type': 'image_hint',
												    'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'),
												    'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'),
												    'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn',
												    'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2),
												    'layers_per_block': 1,
												    'encoder_hid_dim': self.text_embedder_hidden_size,
												    'encoder_hid_dim_type': 'image_proj',
												    'cross_attention_dim': self.cross_attention_dim,
												    'attention_head_dim': 4,
												    'resnet_time_scale_shift': 'scale_shift',
												    'class_embed_type': None,
												}

												UpperCAmelCase             = UNetaDConditionModel(**lowercase_					)
												return model






						@property
						def 	UpperCAmelCase__     (					self :List[str]					)				->			List[Any]:
												return {
												    "block_out_channels": [32, 32, 64, 64],
												    "down_block_types": [
												        "DownEncoderBlock2D",
												        "DownEncoderBlock2D",
												        "DownEncoderBlock2D",
												        "AttnDownEncoderBlock2D",
												    ],
												    "in_channels": 3,
												    "latent_channels": 4,
												    "layers_per_block": 1,
												    "norm_num_groups": 8,
												    "norm_type": "spatial",
												    "num_vq_embeddings": 12,
												    "out_channels": 3,
												    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
												    "vq_embed_dim": 4,
												}






						@property
						def 	UpperCAmelCase__     (					self :List[Any]					)				->			Optional[Any]:
												torch.manual_seed(0					)
												UpperCAmelCase             = VQModel(**self.dummy_movq_kwargs					)
												return model






						def 	UpperCAmelCase__     (					self :str					)				->			Optional[Any]:
												UpperCAmelCase             = self.dummy_unet
												UpperCAmelCase             = self.dummy_movq

												UpperCAmelCase             = DDIMScheduler(
												    num_train_timesteps=10_00   ,  beta_schedule='linear'   ,  beta_start=0.0_0085   ,  beta_end=0.012   ,  clip_sample=lowercase_   ,  set_alpha_to_one=lowercase_   ,  steps_offset=1   ,  prediction_type='epsilon'   ,  thresholding=lowercase_   ,  )

												UpperCAmelCase             = {
												    'unet': unet,
												    'scheduler': scheduler,
												    'movq': movq,
												}
												return components






						def 	UpperCAmelCase__     (					self :Tuple   ,  lowercase_ :Any   ,  lowercase_ :Optional[Any]=0					)				->			Any:
												UpperCAmelCase             = floats_tensor((1, self.text_embedder_hidden_size)   ,  rng=random.Random(lowercase_					)					).to(lowercase_					)
												UpperCAmelCase             = floats_tensor((1, self.text_embedder_hidden_size)   ,  rng=random.Random(seed + 1					)					).to(
												    lowercase_					)

												# create hint
												UpperCAmelCase             = floats_tensor((1, 3, 64, 64)   ,  rng=random.Random(lowercase_					)					).to(lowercase_					)

												if str(lowercase_					).startswith('mps'					):
																		UpperCAmelCase             = torch.manual_seed(lowercase_					)
												else:
																		UpperCAmelCase             = torch.Generator(device=lowercase_					).manual_seed(lowercase_					)
												UpperCAmelCase             = {
												    'image_embeds': image_embeds,
												    'negative_image_embeds': negative_image_embeds,
												    'hint': hint,
												    'generator': generator,
												    'height': 64,
												    'width': 64,
												    'guidance_scale': 4.0,
												    'num_inference_steps': 2,
												    'output_type': 'np',
												}
												return inputs






						def 	UpperCAmelCase__     (					self :List[str]					)				->			Tuple:
												UpperCAmelCase             = 'cpu'

												UpperCAmelCase             = self.get_dummy_components()

												UpperCAmelCase             = self.pipeline_class(**lowercase_					)
												UpperCAmelCase             = pipe.to(lowercase_					)

												pipe.set_progress_bar_config(disable=lowercase_					)

												UpperCAmelCase             = pipe(**self.get_dummy_inputs(lowercase_					)					)
												UpperCAmelCase             = output.images

												UpperCAmelCase             = pipe(
												    **self.get_dummy_inputs(lowercase_					)   ,  return_dict=lowercase_   ,  )[0]

												UpperCAmelCase             = image[0, -3:, -3:, -1]
												UpperCAmelCase             = image_from_tuple[0, -3:, -3:, -1]

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

												UpperCAmelCase             = np.array(
												    [0.695_9826, 0.86_8279, 0.755_8092, 0.6876_9467, 0.8580_5804, 0.6597_7496, 0.4488_5302, 0.595_9111, 0.425_1595]					)

												assert (
												    np.abs(image_slice.flatten() - expected_slice					).max() < 1E-2
												), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""

												assert (
												    np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1E-2
												), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""







@slow
@require_torch_gpu
class       A_			(     unittest.TestCase				):



						"""simple docstring"""






						def 	UpperCAmelCase__     (					self :Optional[Any]					)				->			str:
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def 	UpperCAmelCase__     (					self :List[str]					)				->			str:
												UpperCAmelCase             = load_numpy(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
												    '/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy'					)

												UpperCAmelCase             = load_image(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
												    '/kandinskyv22/hint_image_cat.png'					)
												UpperCAmelCase             = torch.from_numpy(np.array(lowercase_					)					).float() / 255.0
												UpperCAmelCase             = hint.permute(2   ,  0   ,  1					).unsqueeze(0					)

												UpperCAmelCase             = KandinskyVaaPriorPipeline.from_pretrained(
												    'kandinsky-community/kandinsky-2-2-prior'   ,  torch_dtype=torch.floataa					)
												pipe_prior.to(lowercase_					)

												UpperCAmelCase             = KandinskyVaaControlnetPipeline.from_pretrained(
												    'kandinsky-community/kandinsky-2-2-controlnet-depth'   ,  torch_dtype=torch.floataa					)
												UpperCAmelCase             = pipeline.to(lowercase_					)
												pipeline.set_progress_bar_config(disable=lowercase_					)

												UpperCAmelCase             = 'A robot, 4k photo'

												UpperCAmelCase             = torch.Generator(device='cuda'					).manual_seed(0					)
												UpperCAmelCase      ,    UpperCAmelCase             = pipe_prior(
												    lowercase_   ,  generator=lowercase_   ,  num_inference_steps=5   ,  negative_prompt=''   ,  ).to_tuple()

												UpperCAmelCase             = torch.Generator(device='cuda'					).manual_seed(0					)
												UpperCAmelCase             = pipeline(
												    image_embeds=lowercase_   ,  negative_image_embeds=lowercase_   ,  hint=lowercase_   ,  generator=lowercase_   ,  num_inference_steps=1_00   ,  output_type='np'   ,  )

												UpperCAmelCase             = output.images[0]

												assert image.shape == (5_12, 5_12, 3)

												assert_mean_pixel_difference(lowercase_   ,  lowercase_					)












'''simple docstring'''

import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
  from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
  from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
  from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


__lowerCAmelCase							:	Dict			=DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__lowerCAmelCase							:	List[Any]			="main"
# Default branch name
__lowerCAmelCase							:	int			="f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
__lowerCAmelCase							:	List[Any]			="aaaaaaa"
# This commit does not exist, so we should 404.

__lowerCAmelCase							:	Optional[int]			="d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
__lowerCAmelCase							:	Dict			="4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"





@contextlib.contextmanager
def 						UpperCamelCase				(							):
    print("Welcome!"       )
    yield
    print("Bye!"       )





@contextlib.contextmanager
def 						UpperCamelCase				(							):
    print("Bonjour!"       )
    yield
    print("Au revoir!"       )






class    UpperCAmelCase	(       unittest.TestCase				):
 def      UpperCAmelCase_							(				self      :str							)->							List[str]:
     # If the spec is missing, importlib would not be able to import the module dynamically.
     assert transformers.__spec__ is not None
     assert importlib.util.find_spec("transformers"							) is not None






class    UpperCAmelCase	(       unittest.TestCase				):
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]						,       lowercase_      :Union[str, Any]							)->							Any:
     with ContextManagers([]							):
         print("Transformers are awesome!"							)
     # The print statement adds a new line at the end of the output
     self.assertEqual(mock_stdout.getvalue()						,       "Transformers are awesome!\n"							)
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Dict						,       lowercase_      :Optional[Any]							)->							Tuple:
     with ContextManagers([context_en()]							):
         print("Transformers are awesome!"							)
     # The output should be wrapped with an English welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()						,       "Welcome!\nTransformers are awesome!\nBye!\n"							)
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]						,       lowercase_      :int							)->							Union[str, Any]:
     with ContextManagers([context_fr(), context_en()]							):
         print("Transformers are awesome!"							)
     # The output should be wrapped with an English and French welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()						,       "Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"							)
 @require_torch
 def      UpperCAmelCase_							(				self      :int							)->							Dict:
     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["labels", "next_sentence_label"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["start_positions", "end_positions"]							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
 @require_tf
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							Union[str, Any]:
     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["labels", "next_sentence_label"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["start_positions", "end_positions"]							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)



 @require_flax
 def      UpperCAmelCase_							(				self      :Dict							)->							str:
     # Flax models don't have labels
     self.assertEqual(find_labels(lowercase_							)						,       []							)
     self.assertEqual(find_labels(lowercase_							)						,       []							)
     self.assertEqual(find_labels(lowercase_							)						,       []							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       []							)



