





"""simple docstring"""
import argparse
import math
import os

import torch
from neural_compressor.utils.pytorch import load
from PIL import Image
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, StableDiffusionPipeline, UNetaDConditionModel

def 		_SCREAMING_SNAKE_CASE			():
 lowerCAmelCase    				= argparse.ArgumentParser()
 parser.add_argument(
     '-m'  ,     '--pretrained_model_name_or_path'  ,     type=_UpperCAmelCase  ,     default=_UpperCAmelCase  ,     required=_UpperCAmelCase  ,     help='Path to pretrained model or model identifier from huggingface.co/models.'  ,     )
 parser.add_argument(
     '-c'  ,     '--caption'  ,     type=_UpperCAmelCase  ,     default='robotic cat with wings'  ,     help='Text used to generate images.'  ,     )
 parser.add_argument(
     '-n'  ,     '--images_num'  ,     type=_UpperCAmelCase  ,     default=4  ,     help='How much images to generate.'  ,     )
 parser.add_argument(
     '-s'  ,     '--seed'  ,     type=_UpperCAmelCase  ,     default=42  ,     help='Seed for random process.'  ,     )
 parser.add_argument(
     '-ci'  ,     '--cuda_id'  ,     type=_UpperCAmelCase  ,     default=0  ,     help='cuda_id.'  ,     )
 lowerCAmelCase    				= parser.parse_args()
 return args

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    int  ,     _UpperCAmelCase					:    List[Any]  ,     _UpperCAmelCase					:    Optional[int]			):
 if not len(_UpperCAmelCase			) == rows * cols:
  raise ValueError('The specified number of rows and columns are not correct.'			)

 lowerCAmelCase				,lowerCAmelCase    				= imgs[0].size
 lowerCAmelCase    				= Image.new('RGB'  ,     size=(cols * w, rows * h)			)
 lowerCAmelCase				,lowerCAmelCase    				= grid.size

 for i, img in enumerate(_UpperCAmelCase			):
  grid.paste(_UpperCAmelCase  ,     box=(i % cols * w, i // cols * h)			)
 return grid

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Any  ,     _UpperCAmelCase					:    Union[str, Any]="robotic cat with wings"  ,     _UpperCAmelCase					:    Optional[int]=7.5  ,     _UpperCAmelCase					:    Dict=50  ,     _UpperCAmelCase					:    Tuple=1  ,     _UpperCAmelCase					:    int=42  ,     ):
 lowerCAmelCase    				= torch.Generator(pipeline.device			).manual_seed(_UpperCAmelCase			)
 lowerCAmelCase    				= pipeline(
     _UpperCAmelCase  ,     guidance_scale=_UpperCAmelCase  ,     num_inference_steps=_UpperCAmelCase  ,     generator=_UpperCAmelCase  ,     num_images_per_prompt=_UpperCAmelCase  ,     ).images
 lowerCAmelCase    				= int(math.sqrt(_UpperCAmelCase			)			)
 lowerCAmelCase    				= image_grid(_UpperCAmelCase  ,     rows=_rows  ,     cols=num_images_per_prompt // _rows			)
 return grid, images


__UpperCamelCase     :						Optional[Any]						       =  parse_args()
# Load models and create wrapper for stable diffusion
__UpperCamelCase     :						List[Any]						       =  CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='''tokenizer''')
__UpperCamelCase     :						str						       =  CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='''text_encoder''')
__UpperCamelCase     :						Optional[int]						       =  AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder='''vae''')
__UpperCamelCase     :						List[str]						       =  UNetaDConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='''unet''')

__UpperCamelCase     :						Tuple						       =  StableDiffusionPipeline.from_pretrained(
    args.pretrained_model_name_or_path, text_encoder=text_encoder, vae=vae, unet=unet, tokenizer=tokenizer
)
__UpperCamelCase     :						Union[str, Any]						       =  lambda images, clip_input: (images, False)
if os.path.exists(os.path.join(args.pretrained_model_name_or_path, '''best_model.pt''')):
       __UpperCamelCase     :						Dict						       =  load(args.pretrained_model_name_or_path, model=unet)
       unet.eval()
       setattr(pipeline, '''unet''', unet)
else:
       __UpperCamelCase     :						Dict						       =  unet.to(torch.device('''cuda''', args.cuda_id))
__UpperCamelCase     :						Optional[Any]						       =  pipeline.to(unet.device)
__UpperCamelCase       ,__UpperCamelCase     :						List[Any]						       =  generate_images(pipeline, prompt=args.caption, num_images_per_prompt=args.images_num, seed=args.seed)
grid.save(os.path.join(args.pretrained_model_name_or_path, '''{}.png'''.format('''_'''.join(args.caption.split()))))
__UpperCamelCase     :						int						       =  os.path.join(args.pretrained_model_name_or_path, '''_'''.join(args.caption.split()))
os.makedirs(dirname, exist_ok=True)
for idx, image in enumerate(images):
       image.save(os.path.join(dirname, '''{}.png'''.format(idx + 1)))












"""simple docstring"""
import gc
import unittest

import numpy as np
import torch

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS, UNCONDITIONAL_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class       a							(   a__   , unittest.TestCase  ):
 snake_case__             =       DanceDiffusionPipeline
 snake_case__             =       UNCONDITIONAL_AUDIO_GENERATION_PARAMS
 snake_case__             =       PipelineTesterMixin.required_optional_params - {
     '''callback''',
     '''latents''',
     '''callback_steps''',
     '''output_type''',
     '''num_images_per_prompt''',
 }
 snake_case__             =       UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
 snake_case__             =       False
 snake_case__             =       False



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  torch.manual_seed(0     )
  lowerCAmelCase    				= UNetaDModel(
      block_out_channels=(32, 32, 64)				,       extra_in_channels=16				,       sample_size=5_12				,       sample_rate=1_60_00				,       in_channels=2				,       out_channels=2				,       flip_sin_to_cos=_snake_case				,       use_timestep_embedding=_snake_case				,       time_embedding_type='fourier'				,       mid_block_type='UNetMidBlock1D'				,       down_block_types=('DownBlock1DNoSkip', 'DownBlock1D', 'AttnDownBlock1D')				,       up_block_types=('AttnUpBlock1D', 'UpBlock1D', 'UpBlock1DNoSkip')				,       )
  lowerCAmelCase    				= IPNDMScheduler()

  lowerCAmelCase    				= {
      'unet': unet,
      'scheduler': scheduler,
  }
  return components



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=0     ):







  """simple docstring"""






  if str(_snake_case     ).startswith('mps'     ):
   lowerCAmelCase    				= torch.manual_seed(_snake_case     )
  else:
   lowerCAmelCase    				= torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )
  lowerCAmelCase    				= {
      'batch_size': 1,
      'generator': generator,
      'num_inference_steps': 4,
  }
  return inputs



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= 'cpu'  # ensure determinism for the device-dependent torch.Generator
  lowerCAmelCase    				= self.get_dummy_components()
  lowerCAmelCase    				= DanceDiffusionPipeline(**_snake_case     )
  lowerCAmelCase    				= pipe.to(_snake_case     )
  pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= self.get_dummy_inputs(_snake_case     )
  lowerCAmelCase    				= pipe(**_snake_case     )
  lowerCAmelCase    				= output.audios

  lowerCAmelCase    				= audio[0, -3:, -3:]

  assert audio.shape == (1, 2, components["unet"].sample_size)
  lowerCAmelCase    				= np.array([-0.7_265, 1.0_000, -0.8_388, 0.1_175, 0.9_498, -1.0_000]     )
  assert np.abs(audio_slice.flatten() - expected_slice     ).max() < 1E-2



 @skip_mps
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return super().test_save_load_local()



 @skip_mps
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3     )



 @skip_mps
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return super().test_save_load_optional_components()



 @skip_mps
 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return super().test_attention_slicing_forward_pass()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  super().test_inference_batch_single_identical(expected_max_diff=3E-3     )







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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= torch_device

  lowerCAmelCase    				= DanceDiffusionPipeline.from_pretrained('harmonai/maestro-150k'     )
  lowerCAmelCase    				= pipe.to(_snake_case     )
  pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= torch.manual_seed(0     )
  lowerCAmelCase    				= pipe(generator=_snake_case				,       num_inference_steps=1_00				,       audio_length_in_s=4.096     )
  lowerCAmelCase    				= output.audios

  lowerCAmelCase    				= audio[0, -3:, -3:]

  assert audio.shape == (1, 2, pipe.unet.sample_size)
  lowerCAmelCase    				= np.array([-0.0_192, -0.0_231, -0.0_318, -0.0_059, 0.0_002, -0.0_020]     )

  assert np.abs(audio_slice.flatten() - expected_slice     ).max() < 1E-2



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= torch_device

  lowerCAmelCase    				= DanceDiffusionPipeline.from_pretrained('harmonai/maestro-150k'				,       torch_dtype=torch.floataa     )
  lowerCAmelCase    				= pipe.to(_snake_case     )
  pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= torch.manual_seed(0     )
  lowerCAmelCase    				= pipe(generator=_snake_case				,       num_inference_steps=1_00				,       audio_length_in_s=4.096     )
  lowerCAmelCase    				= output.audios

  lowerCAmelCase    				= audio[0, -3:, -3:]

  assert audio.shape == (1, 2, pipe.unet.sample_size)
  lowerCAmelCase    				= np.array([-0.0_367, -0.0_488, -0.0_771, -0.0_525, -0.0_444, -0.0_341]     )

  assert np.abs(audio_slice.flatten() - expected_slice     ).max() < 1E-2





