code: 
  
  
  
  import random
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
  from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch
  
  
  enable_full_determinism()
  
  
  
  
  
  
  class 	lowercase		(				unittest.TestCase):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	@property
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[Any]  )    ->				Any:
  							UpperCAmelCase_=     1
  							UpperCAmelCase_=     3
  							UpperCAmelCase_=     (32, 32)
  
  							UpperCAmelCase_=     floats_tensor((batch_size, num_channels) + sizes		,						rng=random.Random(0  )  ).to(__UpperCAmelCase  )
  							return image
  
  
  
  
  	@property
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				List[str]:
  							torch.manual_seed(0  )
  							UpperCAmelCase_=     UNetaDModel(
  							    block_out_channels=(32, 64)		,						layers_per_block=2		,						sample_size=32		,						in_channels=6		,						out_channels=3		,						down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")		,						up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")		,						)
  							return model
  
  
  
  
  	@property
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				List[Any]:
  							torch.manual_seed(0  )
  							UpperCAmelCase_=     VQModel(
  							    block_out_channels=[32, 64]		,						in_channels=3		,						out_channels=3		,						down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]		,						up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]		,						latent_channels=3		,						)
  							return model
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Any:
  							UpperCAmelCase_=     """cpu"""
  							UpperCAmelCase_=     self.dummy_uncond_unet
  							UpperCAmelCase_=     DDIMScheduler()
  							UpperCAmelCase_=     self.dummy_vq_model
  
  							UpperCAmelCase_=     LDMSuperResolutionPipeline(unet=__UpperCAmelCase		,						vqvae=__UpperCAmelCase		,						scheduler=__UpperCAmelCase  )
  							ldm.to(__UpperCAmelCase  )
  							ldm.set_progress_bar_config(disable=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     self.dummy_image.to(__UpperCAmelCase  )
  
  							UpperCAmelCase_=     torch.Generator(device=__UpperCAmelCase  ).manual_seed(0  )
  							UpperCAmelCase_=     ldm(image=__UpperCAmelCase		,						generator=__UpperCAmelCase		,						num_inference_steps=2		,						output_type="""numpy"""  ).images
  
  							UpperCAmelCase_=     image[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 64, 64, 3)
  							UpperCAmelCase_=     np.array([0.8_678, 0.8_245, 0.6_381, 0.6_830, 0.4_385, 0.5_599, 0.4_641, 0.6_201, 0.5_150]  )
  
  							assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2
  
  
  
  
  	@unittest.skipIf(torch_device != """cuda"""		,						"""This test requires a GPU"""  )
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				Any:
  							UpperCAmelCase_=     self.dummy_uncond_unet
  							UpperCAmelCase_=     DDIMScheduler()
  							UpperCAmelCase_=     self.dummy_vq_model
  
  							# put models in fp16
  							UpperCAmelCase_=     unet.half()
  							UpperCAmelCase_=     vqvae.half()
  
  							UpperCAmelCase_=     LDMSuperResolutionPipeline(unet=__UpperCAmelCase		,						vqvae=__UpperCAmelCase		,						scheduler=__UpperCAmelCase  )
  							ldm.to(__UpperCAmelCase  )
  							ldm.set_progress_bar_config(disable=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     self.dummy_image.to(__UpperCAmelCase  )
  
  							UpperCAmelCase_=     ldm(__UpperCAmelCase		,						num_inference_steps=2		,						output_type="""numpy"""  ).images
  
  							assert image.shape == (1, 64, 64, 3)
  
  
  
  
  
  
  @slow
  @require_torch
  class 	lowercase		(				unittest.TestCase):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Optional[int]:
  							UpperCAmelCase_=     load_image(
  							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
  							    """/vq_diffusion/teddy_bear_pool.png"""  )
  							UpperCAmelCase_=     init_image.resize((64, 64)		,						resample=PIL_INTERPOLATION["""lanczos"""]  )
  
  							UpperCAmelCase_=     LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""		,						device_map="""auto"""  )
  							ldm.set_progress_bar_config(disable=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     torch.manual_seed(0  )
  							UpperCAmelCase_=     ldm(image=__UpperCAmelCase		,						generator=__UpperCAmelCase		,						num_inference_steps=20		,						output_type="""numpy"""  ).images
  
  							UpperCAmelCase_=     image[0, -3:, -3:, -1]
  
  							assert image.shape == (1, 256, 256, 3)
  							UpperCAmelCase_=     np.array([0.7_644, 0.7_679, 0.7_642, 0.7_633, 0.7_666, 0.7_560, 0.7_425, 0.7_257, 0.6_907]  )
  
  							assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2
  
  
  
  
  
style_context: 
  
  
  
  import copy
  from typing import Dict
  
  from ...generation.configuration_utils import GenerationConfig
  from ...utils import logging
  
  
  __A       					=		logging.get_logger(__name__)
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Optional[int]	     =							"semantic"
  
  
  
  
  	def __init__(			self			:		Any		,						__UpperCAmelCase			:		List[str]=10_000		,						__UpperCAmelCase			:		List[Any]=True		,						__UpperCAmelCase			:		int=768		,						__UpperCAmelCase			:		Dict=False		,						__UpperCAmelCase			:		str=False		,						__UpperCAmelCase			:		Optional[int]=False		,						__UpperCAmelCase			:		int=False		,						__UpperCAmelCase			:		Union[str, Any]=0.7		,						__UpperCAmelCase			:		Optional[Any]=True		,						__UpperCAmelCase			:		int=10_048		,						__UpperCAmelCase			:		Dict=129_595		,						__UpperCAmelCase			:		Optional[Any]=129_599		,						__UpperCAmelCase			:		Tuple=10_000		,						__UpperCAmelCase			:		List[Any]=256		,						__UpperCAmelCase			:		Union[str, Any]=49.9		,						**__UpperCAmelCase			:		Optional[Any]		,						)    ->				Tuple:
  							super().__init__(
  							    temperature=__UpperCAmelCase		,						do_sample=__UpperCAmelCase		,						eos_token_id=__UpperCAmelCase		,						renormalize_logits=__UpperCAmelCase		,						max_new_tokens=__UpperCAmelCase		,						output_scores=__UpperCAmelCase		,						return_dict_in_generate=__UpperCAmelCase		,						output_hidden_states=__UpperCAmelCase		,						output_attentions=__UpperCAmelCase		,						**__UpperCAmelCase		,						)
  
  							UpperCAmelCase_=     text_encoding_offset
  							UpperCAmelCase_=     text_pad_token
  							UpperCAmelCase_=     eos_token_id
  							UpperCAmelCase_=     semantic_infer_token
  							UpperCAmelCase_=     semantic_vocab_size
  							UpperCAmelCase_=     max_input_semantic_length
  							UpperCAmelCase_=     semantic_rate_hz
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Any	     =							"coarse_acoustics"
  
  
  
  
  	def __init__(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]=True		,						__UpperCAmelCase			:		Optional[int]=False		,						__UpperCAmelCase			:		Union[str, Any]=False		,						__UpperCAmelCase			:		List[str]=False		,						__UpperCAmelCase			:		Any=False		,						__UpperCAmelCase			:		Union[str, Any]=0.7		,						__UpperCAmelCase			:		List[Any]=True		,						__UpperCAmelCase			:		Optional[int]=12_048		,						__UpperCAmelCase			:		Optional[Any]=75		,						__UpperCAmelCase			:		str=2		,						__UpperCAmelCase			:		Optional[int]=12_050		,						__UpperCAmelCase			:		Union[str, Any]=256		,						__UpperCAmelCase			:		int = 630		,						__UpperCAmelCase			:		int = 60		,						**__UpperCAmelCase			:		int		,						)    ->				Union[str, Any]:
  							super().__init__(
  							    temperature=__UpperCAmelCase		,						do_sample=__UpperCAmelCase		,						renormalize_logits=__UpperCAmelCase		,						output_scores=__UpperCAmelCase		,						return_dict_in_generate=__UpperCAmelCase		,						output_hidden_states=__UpperCAmelCase		,						output_attentions=__UpperCAmelCase		,						**__UpperCAmelCase		,						)
  
  							UpperCAmelCase_=     coarse_semantic_pad_token
  							UpperCAmelCase_=     coarse_rate_hz
  							UpperCAmelCase_=     n_coarse_codebooks
  							UpperCAmelCase_=     coarse_infer_token
  							UpperCAmelCase_=     max_coarse_input_length
  							UpperCAmelCase_=     max_coarse_history
  							UpperCAmelCase_=     sliding_window_len
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Tuple	     =							"fine_acoustics"
  
  
  
  
  	def __init__(			self			:		Tuple		,						__UpperCAmelCase			:		Tuple=0.5		,						__UpperCAmelCase			:		Optional[Any]=512		,						__UpperCAmelCase			:		Optional[Any]=1_024		,						__UpperCAmelCase			:		List[str]=8		,						**__UpperCAmelCase			:		str		,						)    ->				Tuple:
  							super().__init__(temperature=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     max_fine_history_length
  							UpperCAmelCase_=     max_fine_input_length
  							UpperCAmelCase_=     n_fine_codebooks
  
  
  
  
  
  
  class 	lowercase		(				snake_case__):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      Any	     =							"bark"
  	a__   :      List[str]	     =							True
  
  
  
  
  	def __init__(			self			:		List[str]		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		Dict = None		,						__UpperCAmelCase			:		str=24_000		,						__UpperCAmelCase			:		List[str]=1_024		,						**__UpperCAmelCase			:		Optional[int]		,						)    ->				List[str]:
  							if semantic_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""semantic_config is None. initializing the semantic model with default values."""  )
  
  							if coarse_acoustics_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""coarse_acoustics_config is None. initializing the coarse model with default values."""  )
  
  							if fine_acoustics_config is None:
  													UpperCAmelCase_=     {}
  													logger.info("""fine_acoustics_config is None. initializing the fine model with default values."""  )
  
  							UpperCAmelCase_=     BarkSemanticGenerationConfig(**__UpperCAmelCase  )
  							UpperCAmelCase_=     BarkCoarseGenerationConfig(**__UpperCAmelCase  )
  							UpperCAmelCase_=     BarkFineGenerationConfig(**__UpperCAmelCase  )
  
  							UpperCAmelCase_=     sample_rate
  							UpperCAmelCase_=     codebook_size
  
  
  
  
  	@classmethod
  	def 						_SCREAMING_SNAKE_CASE	(			cls			:		str		,						__UpperCAmelCase			:		BarkSemanticGenerationConfig		,						__UpperCAmelCase			:		BarkCoarseGenerationConfig		,						__UpperCAmelCase			:		BarkFineGenerationConfig		,						**__UpperCAmelCase			:		Any		,						)    ->				Any:
  							return cls(
  							    semantic_config=semantic_config.to_dict()		,						coarse_acoustics_config=coarse_acoustics_config.to_dict()		,						fine_acoustics_config=fine_acoustics_config.to_dict()		,						**__UpperCAmelCase		,						)
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				Optional[Any]:
  							UpperCAmelCase_=     copy.deepcopy(self.__dict__  )
  
  							UpperCAmelCase_=     self.semantic_config.to_dict()
  							UpperCAmelCase_=     self.coarse_acoustics_config.to_dict()
  							UpperCAmelCase_=     self.fine_acoustics_config.to_dict()
  
  							UpperCAmelCase_=     self.__class__.model_type
  							return output
  
  
  
  
  