




'''simple docstring'''







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
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						(			__a							,							unittest.TestCase				):
       __a       :  Optional[Any]            =      KandinskyImgaImgPipeline
       __a       :  List[str]            =      ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
       __a       :  int            =      [
           """prompt""",
           """negative_prompt""",
           """image_embeds""",
           """negative_image_embeds""",
           """image""",
       ]
       __a       :  Union[str, Any]            =      [
           """generator""",
           """height""",
           """width""",
           """strength""",
           """guidance_scale""",
           """negative_prompt""",
           """num_inference_steps""",
           """return_dict""",
           """guidance_scale""",
           """num_images_per_prompt""",
           """output_type""",
           """return_dict""",
       ]
       __a       :  Any            =      False
       @property
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           return self.time_input_dim
       @property
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           return self.time_input_dim * 4
       @property
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           return 100
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''       )
           return tokenizer
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )
           UpperCAmelCase     =	MCLIPConfig(
               numDims=self.cross_attention_dim     ,       transformerDimensions=self.text_embedder_hidden_size     ,       hidden_size=self.text_embedder_hidden_size     ,       intermediate_size=37     ,       num_attention_heads=4     ,       num_hidden_layers=5     ,       vocab_size=1_005     ,       )

           UpperCAmelCase     =	MultilingualCLIP(_SCREAMING_SNAKE_CASE       )
           UpperCAmelCase     =	text_encoder.eval()

           return text_encoder
       @property
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           torch.manual_seed(0       )

           UpperCAmelCase     =	{
               '''in_channels''': 4,
               # Out channels is double in channels because predicts mean and variance
               '''out_channels''': 8,
               '''addition_embed_type''': '''text_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''': '''text_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(**_SCREAMING_SNAKE_CASE       )
           return model
       @property
       def 					A   (			self		:			Optional[int]       ):



           '''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 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )
           UpperCAmelCase     =	VQModel(**self.dummy_movq_kwargs       )
           return model
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.dummy_text_encoder
           UpperCAmelCase     =	self.dummy_tokenizer
           UpperCAmelCase     =	self.dummy_unet
           UpperCAmelCase     =	self.dummy_movq

           UpperCAmelCase     =	{
               '''num_train_timesteps''': 1_000,
               '''beta_schedule''': '''linear''',
               '''beta_start''': 0.0_0085,
               '''beta_end''': 0.012,
               '''clip_sample''': False,
               '''set_alpha_to_one''': False,
               '''steps_offset''': 0,
               '''prediction_type''': '''epsilon''',
               '''thresholding''': False,
           }

           UpperCAmelCase     =	DDIMScheduler(**_SCREAMING_SNAKE_CASE       )

           UpperCAmelCase     =	{
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''unet''': unet,
               '''scheduler''': scheduler,
               '''movq''': movq,
           }

           return components
       def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			Any     ,       lowercase		:			Dict=0       ):



           '''simple docstring'''

           UpperCAmelCase     =	floats_tensor((1, self.cross_attention_dim)     ,       rng=random.Random(_SCREAMING_SNAKE_CASE       )       ).to(_SCREAMING_SNAKE_CASE       )
           UpperCAmelCase     =	floats_tensor((1, self.cross_attention_dim)     ,       rng=random.Random(seed + 1       )       ).to(_SCREAMING_SNAKE_CASE       )
           # create init_image
           UpperCAmelCase     =	floats_tensor((1, 3, 64, 64)     ,       rng=random.Random(_SCREAMING_SNAKE_CASE       )       ).to(_SCREAMING_SNAKE_CASE       )
           UpperCAmelCase     =	image.cpu().permute(0     ,       2     ,       3     ,       1       )[0]
           UpperCAmelCase     =	Image.fromarray(np.uinta(_SCREAMING_SNAKE_CASE       )       ).convert('''RGB'''       ).resize((256, 256)       )

           if str(_SCREAMING_SNAKE_CASE       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(_SCREAMING_SNAKE_CASE       )
           else:
               UpperCAmelCase     =	torch.Generator(device=_SCREAMING_SNAKE_CASE       ).manual_seed(_SCREAMING_SNAKE_CASE       )
           UpperCAmelCase     =	{
               '''prompt''': '''horse''',
               '''image''': init_image,
               '''image_embeds''': image_embeds,
               '''negative_image_embeds''': negative_image_embeds,
               '''generator''': generator,
               '''height''': 64,
               '''width''': 64,
               '''num_inference_steps''': 10,
               '''guidance_scale''': 7.0,
               '''strength''': 0.2,
               '''output_type''': '''np''',
           }
           return inputs







       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	'''cpu'''

           UpperCAmelCase     =	self.get_dummy_components()

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

           pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE       )

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

           UpperCAmelCase     =	pipe(
               **self.get_dummy_inputs(_SCREAMING_SNAKE_CASE       )     ,       return_dict=_SCREAMING_SNAKE_CASE     ,       )[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.6147_4943, 0.607_3539, 0.4330_8544, 0.592_8269, 0.4749_3595, 0.4675_5973, 0.461_3838, 0.4536_8797, 0.5011_9233]       )
           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 					A   (			self		:			Any       ):



           '''simple docstring'''

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







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



           '''simple docstring'''

           UpperCAmelCase     =	load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/kandinsky/kandinsky_img2img_frog.npy'''       )

           UpperCAmelCase     =	load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''       )
           UpperCAmelCase     =	'''A red cartoon frog, 4k'''

           UpperCAmelCase     =	KandinskyPriorPipeline.from_pretrained(
               '''kandinsky-community/kandinsky-2-1-prior'''     ,       torch_dtype=torch.floataa       )
           pipe_prior.to(_SCREAMING_SNAKE_CASE       )

           UpperCAmelCase     =	KandinskyImgaImgPipeline.from_pretrained(
               '''kandinsky-community/kandinsky-2-1'''     ,       torch_dtype=torch.floataa       )
           UpperCAmelCase     =	pipeline.to(_SCREAMING_SNAKE_CASE       )

           pipeline.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE       )

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

           UpperCAmelCase     =	pipeline(
               _SCREAMING_SNAKE_CASE     ,       image=_SCREAMING_SNAKE_CASE     ,       image_embeds=_SCREAMING_SNAKE_CASE     ,       negative_image_embeds=_SCREAMING_SNAKE_CASE     ,       generator=_SCREAMING_SNAKE_CASE     ,       num_inference_steps=100     ,       height=768     ,       width=768     ,       strength=0.2     ,       output_type='''np'''     ,       )

           UpperCAmelCase     =	output.images[0]

           assert image.shape == (768, 768, 3)

           assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE       )










'''simple docstring'''







import math
from typing import Optional

import numpy as np

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A									=logging.get_logger(__name__)

A									={
    'facebook/encodec_24khz': 'https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json',
    'facebook/encodec_48khz': 'https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json',
}


class     _a						(			__a				):
       __a       :  Union[str, Any]            =      """encodec"""
       def __init__(			self		:			Optional[int]     ,       lowercase		:			Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0]     ,       lowercase		:			str=24_000     ,       lowercase		:			int=1     ,       lowercase		:			int=False     ,       lowercase		:			List[str]=None     ,       lowercase		:			Tuple=None     ,       lowercase		:			int=128     ,       lowercase		:			List[Any]=32     ,       lowercase		:			Optional[int]=1     ,       lowercase		:			Optional[int]=[8, 5, 4, 2]     ,       lowercase		:			Union[str, Any]="weight_norm"     ,       lowercase		:			Optional[int]=7     ,       lowercase		:			Tuple=7     ,       lowercase		:			Tuple=3     ,       lowercase		:			Union[str, Any]=2     ,       lowercase		:			Optional[Any]=True     ,       lowercase		:			Tuple="reflect"     ,       lowercase		:			Any=2     ,       lowercase		:			List[str]=2     ,       lowercase		:			str=1.0     ,       lowercase		:			List[str]=1_024     ,       lowercase		:			Optional[Any]=None     ,       lowercase		:			Any=True     ,       **lowercase		:			Optional[Any]     ,       ):



           '''simple docstring'''

           UpperCAmelCase     =	target_bandwidths
           UpperCAmelCase     =	sampling_rate
           UpperCAmelCase     =	audio_channels
           UpperCAmelCase     =	normalize
           UpperCAmelCase     =	chunk_length_s
           UpperCAmelCase     =	overlap
           UpperCAmelCase     =	hidden_size
           UpperCAmelCase     =	num_filters
           UpperCAmelCase     =	num_residual_layers
           UpperCAmelCase     =	upsampling_ratios
           UpperCAmelCase     =	norm_type
           UpperCAmelCase     =	kernel_size
           UpperCAmelCase     =	last_kernel_size
           UpperCAmelCase     =	residual_kernel_size
           UpperCAmelCase     =	dilation_growth_rate
           UpperCAmelCase     =	use_causal_conv
           UpperCAmelCase     =	pad_mode
           UpperCAmelCase     =	compress
           UpperCAmelCase     =	num_lstm_layers
           UpperCAmelCase     =	trim_right_ratio
           UpperCAmelCase     =	codebook_size
           UpperCAmelCase     =	codebook_dim if codebook_dim is not None else hidden_size
           UpperCAmelCase     =	use_conv_shortcut

           if self.norm_type not in ["weight_norm", "time_group_norm"]:
               raise ValueError(
                   f"self.norm_type must be one of `\"weight_norm\"`, `\"time_group_norm\"`), got {self.norm_type}"       )

           super().__init__(**lowercase       )
       @property
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           if self.chunk_length_s is None:
               return None
           else:
               return int(self.chunk_length_s * self.sampling_rate       )
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           if self.chunk_length_s is None or self.overlap is None:
               return None
           else:
               return max(1     ,       int((1.0 - self.overlap) * self.chunk_length       )       )
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	np.prod(self.upsampling_ratios       )
           return math.ceil(self.sampling_rate / hop_length       )







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



           '''simple docstring'''

           return int(1_000 * self.target_bandwidths[-1] // (self.frame_rate * 10)       )




