'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.utils import floats_tensor, 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__ (  UpperCAmelCase__				,  unittest.TestCase					):
     lowerCamelCase    :	Optional[Any]				=KandinskyVaaPipeline
     lowerCamelCase    :	Union[str, Any]				=[
         "image_embeds",
         "negative_image_embeds",
     ]
     lowerCamelCase    :	List[Any]				=["image_embeds", "negative_image_embeds"]
     lowerCamelCase    :	str				=[
         "generator",
         "height",
         "width",
         "latents",
         "guidance_scale",
         "num_inference_steps",
         "return_dict",
         "guidance_scale",
         "num_images_per_prompt",
         "output_type",
         "return_dict",
     ]
     lowerCamelCase    :	Any				=False






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         return 32






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





         """simple docstring"""



         return 32






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         return self.time_input_dim






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



         return self.time_input_dim * 4






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



         return 1_00






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """simple docstring"""



         torch.manual_seed(0       )

         __lowerCamelCase            =    {
             '''in_channels''': 4,
             # Out channels is double in channels because predicts mean and variance
             '''out_channels''': 8,
             '''addition_embed_type''': '''image''',
             '''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,
         }

         __lowerCamelCase            =    UNetaDConditionModel(**a       )
         return model






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





         """simple docstring"""



         return {
             "block_out_channels": [32, 64],
             "down_block_types": ["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",
             ],
             "vq_embed_dim": 4,
         }






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						int       ):





         """simple docstring"""



         torch.manual_seed(0       )
         __lowerCamelCase            =    VQModel(**self.dummy_movq_kwargs       )
         return model






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    self.dummy_unet
         __lowerCamelCase            =    self.dummy_movq

         __lowerCamelCase            =    DDIMScheduler(
             num_train_timesteps=10_00    ,							beta_schedule='''linear'''    ,							beta_start=0.0_00_85    ,							beta_end=0.0_12    ,							clip_sample=a    ,							set_alpha_to_one=a    ,							steps_offset=1    ,							prediction_type='''epsilon'''    ,							thresholding=a    ,							)

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]    ,							a						:						Dict    ,							a						:						int=0       ):





         """simple docstring"""



         __lowerCamelCase            =    floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(a       )       ).to(a       )
         __lowerCamelCase            =    floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(seed + 1       )       ).to(
             a       )
         if str(a       ).startswith('''mps'''       ):
             __lowerCamelCase            =    torch.manual_seed(a       )
         else:
             __lowerCamelCase            =    torch.Generator(device=a       ).manual_seed(a       )
         __lowerCamelCase            =    {
             '''image_embeds''': image_embeds,
             '''negative_image_embeds''': negative_image_embeds,
             '''generator''': generator,
             '''height''': 64,
             '''width''': 64,
             '''guidance_scale''': 4.0,
             '''num_inference_steps''': 2,
             '''output_type''': '''np''',
         }
         return inputs






     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase            =    '''cpu'''

         __lowerCamelCase            =    self.get_dummy_components()

         __lowerCamelCase            =    self.pipeline_class(**a       )
         __lowerCamelCase            =    pipe.to(a       )

         pipe.set_progress_bar_config(disable=a       )

         __lowerCamelCase            =    pipe(**self.get_dummy_inputs(a       )       )
         __lowerCamelCase            =    output.images

         __lowerCamelCase            =    pipe(
             **self.get_dummy_inputs(a       )    ,							return_dict=a    ,							)[0]

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

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

         __lowerCamelCase            =    np.array(
             [0.6_23_79_76, 1.0, 0.36_44_13_32, 1.0, 0.70_63_96_34, 0.29_87_71_86, 0.85_65_21_25, 0.5_21_68_43, 0.54_45_40_46]       )

         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					):






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy'''       )

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

         __lowerCamelCase            =    KandinskyVaaPipeline.from_pretrained(
             '''kandinsky-community/kandinsky-2-2-decoder'''    ,							torch_dtype=torch.floataa       )
         __lowerCamelCase            =    pipeline.to(a       )
         pipeline.set_progress_bar_config(disable=a       )

         __lowerCamelCase            =    '''red cat, 4k photo'''

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

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

         __lowerCamelCase            =    output.images[0]

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

         assert_mean_pixel_difference(a    ,							a       )

'''simple docstring'''




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__UpperCAmelCase					={
    "configuration_efficientnet": [
        "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientNetConfig",
        "EfficientNetOnnxConfig",
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=["EfficientNetImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=[
      "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST",
      "EfficientNetForImageClassification",
      "EfficientNetModel",
      "EfficientNetPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_efficientnet import (
      EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
      EfficientNetConfig,
      EfficientNetOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_efficientnet import EfficientNetImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_efficientnet import (
        EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
        EfficientNetForImageClassification,
        EfficientNetModel,
        EfficientNetPreTrainedModel,
    )

else:
  import sys

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