
'''simple docstring'''


import gc
import unittest

import numpy as np
import torch

from diffusers import (
    AudioDiffusionPipeline,
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    DiffusionPipeline,
    Mel,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class 						lowercase__	(  unittest.TestCase   ):






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







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







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      torch.manual_seed(0   )
      UpperCamelCase       =  UNetaDModel(
          sample_size=(3_2, 6_4) ,   in_channels=1 ,   out_channels=1 ,   layers_per_block=2 ,   block_out_channels=(1_2_8, 1_2_8) ,   down_block_types=('''AttnDownBlock2D''', '''DownBlock2D''') ,   up_block_types=('''UpBlock2D''', '''AttnUpBlock2D''') ,   )
      return model







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      torch.manual_seed(0   )
      UpperCamelCase       =  UNetaDConditionModel(
          sample_size=(6_4, 3_2) ,   in_channels=1 ,   out_channels=1 ,   layers_per_block=2 ,   block_out_channels=(1_2_8, 1_2_8) ,   down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''') ,   up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''') ,   cross_attention_dim=1_0 ,   )
      return model







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      torch.manual_seed(0   )
      UpperCamelCase       =  AutoencoderKL(
          sample_size=(1_2_8, 6_4) ,   in_channels=1 ,   out_channels=1 ,   latent_channels=1 ,   layers_per_block=2 ,   block_out_channels=(1_2_8, 1_2_8) ,   down_block_types=('''DownEncoderBlock2D''', '''DownEncoderBlock2D''') ,   up_block_types=('''UpDecoderBlock2D''', '''UpDecoderBlock2D''') ,   )
      UpperCamelCase       =  UNetaDModel(
          sample_size=(6_4, 3_2) ,   in_channels=1 ,   out_channels=1 ,   layers_per_block=2 ,   block_out_channels=(1_2_8, 1_2_8) ,   down_block_types=('''AttnDownBlock2D''', '''DownBlock2D''') ,   up_block_types=('''UpBlock2D''', '''AttnUpBlock2D''') ,   )
      return vqvae, unet







   @slow
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
      UpperCamelCase       =  Mel(
          x_res=self.dummy_unet.config.sample_size[1] ,   y_res=self.dummy_unet.config.sample_size[0] ,   )

      UpperCamelCase       =  DDPMScheduler()
      UpperCamelCase       =  AudioDiffusionPipeline(vqvae=lowerCamelCase__ ,   unet=self.dummy_unet ,   mel=lowerCamelCase__ ,   scheduler=lowerCamelCase__   )
      UpperCamelCase       =  pipe.to(lowerCamelCase__   )
      pipe.set_progress_bar_config(disable=lowerCamelCase__   )

      UpperCamelCase       =  torch.Generator(device=lowerCamelCase__   ).manual_seed(4_2   )
      UpperCamelCase       =  pipe(generator=lowerCamelCase__ ,   steps=4   )
      UpperCamelCase       =  output.audios[0]
      UpperCamelCase       =  output.images[0]

      UpperCamelCase       =  torch.Generator(device=lowerCamelCase__   ).manual_seed(4_2   )
      UpperCamelCase       =  pipe(generator=lowerCamelCase__ ,   steps=4 ,   return_dict=lowerCamelCase__   )
      UpperCamelCase       =  output[0][0]

      assert audio.shape == (1, (self.dummy_unet.config.sample_size[1] - 1) * mel.hop_length)
      assert (
          image.height == self.dummy_unet.config.sample_size[0]
          and image.width == self.dummy_unet.config.sample_size[1]
      )
      UpperCamelCase       =  np.frombuffer(image.tobytes() ,   dtype='''uint8'''   )[:1_0]
      UpperCamelCase       =  np.frombuffer(image_from_tuple.tobytes() ,   dtype='''uint8'''   )[:1_0]
      UpperCamelCase       =  np.array([6_9, 2_5_5, 2_5_5, 2_5_5, 0, 0, 7_7, 1_8_1, 1_2, 1_2_7]   )

      assert np.abs(image_slice.flatten() - expected_slice   ).max() == 0
      assert np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() == 0

      UpperCamelCase       =  Mel(
          x_res=self.dummy_vqvae_and_unet[0].config.sample_size[1] ,   y_res=self.dummy_vqvae_and_unet[0].config.sample_size[0] ,   )

      UpperCamelCase       =  DDIMScheduler()
      UpperCamelCase       =  self.dummy_vqvae_and_unet
      UpperCamelCase       =  AudioDiffusionPipeline(
          vqvae=self.dummy_vqvae_and_unet[0] ,   unet=dummy_vqvae_and_unet[1] ,   mel=lowerCamelCase__ ,   scheduler=lowerCamelCase__   )
      UpperCamelCase       =  pipe.to(lowerCamelCase__   )
      pipe.set_progress_bar_config(disable=lowerCamelCase__   )

      np.random.seed(0   )
      UpperCamelCase       =  np.random.uniform(-1 ,   1 ,   ((dummy_vqvae_and_unet[0].config.sample_size[1] - 1) * mel.hop_length,)   )
      UpperCamelCase       =  torch.Generator(device=lowerCamelCase__   ).manual_seed(4_2   )
      UpperCamelCase       =  pipe(raw_audio=lowerCamelCase__ ,   generator=lowerCamelCase__ ,   start_step=5 ,   steps=1_0   )
      UpperCamelCase       =  output.images[0]

      assert (
          image.height == self.dummy_vqvae_and_unet[0].config.sample_size[0]
          and image.width == self.dummy_vqvae_and_unet[0].config.sample_size[1]
      )
      UpperCamelCase       =  np.frombuffer(image.tobytes() ,   dtype='''uint8'''   )[:1_0]
      UpperCamelCase       =  np.array([1_2_0, 1_1_7, 1_1_0, 1_0_9, 1_3_8, 1_6_7, 1_3_8, 1_4_8, 1_3_2, 1_2_1]   )

      assert np.abs(image_slice.flatten() - expected_slice   ).max() == 0

      UpperCamelCase       =  self.dummy_unet_condition
      UpperCamelCase       =  AudioDiffusionPipeline(
          vqvae=self.dummy_vqvae_and_unet[0] ,   unet=lowerCamelCase__ ,   mel=lowerCamelCase__ ,   scheduler=lowerCamelCase__   )
      UpperCamelCase       =  pipe.to(lowerCamelCase__   )
      pipe.set_progress_bar_config(disable=lowerCamelCase__   )

      np.random.seed(0   )
      UpperCamelCase       =  torch.rand((1, 1, 1_0)   )
      UpperCamelCase       =  pipe(generator=lowerCamelCase__ ,   encoding=lowerCamelCase__   )
      UpperCamelCase       =  output.images[0]
      UpperCamelCase       =  np.frombuffer(image.tobytes() ,   dtype='''uint8'''   )[:1_0]
      UpperCamelCase       =  np.array([1_0_7, 1_0_3, 1_2_0, 1_2_7, 1_4_2, 1_2_2, 1_1_3, 1_2_2, 9_7, 1_1_1]   )

      assert np.abs(image_slice.flatten() - expected_slice   ).max() == 0




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






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







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







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  torch_device

      UpperCamelCase       =  DiffusionPipeline.from_pretrained('''teticio/audio-diffusion-ddim-256'''   )
      UpperCamelCase       =  pipe.to(lowerCamelCase__   )
      pipe.set_progress_bar_config(disable=lowerCamelCase__   )

      UpperCamelCase       =  torch.Generator(device=lowerCamelCase__   ).manual_seed(4_2   )
      UpperCamelCase       =  pipe(generator=lowerCamelCase__   )
      UpperCamelCase       =  output.audios[0]
      UpperCamelCase       =  output.images[0]

      assert audio.shape == (1, (pipe.unet.config.sample_size[1] - 1) * pipe.mel.hop_length)
      assert image.height == pipe.unet.config.sample_size[0] and image.width == pipe.unet.config.sample_size[1]
      UpperCamelCase       =  np.frombuffer(image.tobytes() ,   dtype='''uint8'''   )[:1_0]
      UpperCamelCase       =  np.array([1_5_1, 1_6_7, 1_5_4, 1_4_4, 1_2_2, 1_3_4, 1_2_1, 1_0_5, 7_0, 2_6]   )

      assert np.abs(image_slice.flatten() - expected_slice   ).max() == 0







'''simple docstring'''


from typing import Dict, Iterable, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_pytesseract_available, is_vision_available, logging, requires_backends


if is_vision_available():
   import PIL

# soft dependency
if is_pytesseract_available():
   import pytesseract

snake_case_ :  Tuple     =					logging.get_logger(__name__)



def  __snake_case     (    _UpperCAmelCase					:       str,      _UpperCAmelCase					:       int,      _UpperCAmelCase					:       Optional[int]):
   return [
       int(1000 * (box[0] / width)),
       int(1000 * (box[1] / height)),
       int(1000 * (box[2] / width)),
       int(1000 * (box[3] / height)),
   ]



def  __snake_case     (    _UpperCAmelCase					:       np.ndarray,      _UpperCAmelCase					:       Optional[str],      _UpperCAmelCase					:       Optional[str]):
   UpperCamelCase       =  to_pil_image(_UpperCAmelCase)
   UpperCamelCase     , UpperCamelCase       =  pil_image.size
   UpperCamelCase       =  pytesseract.image_to_data(_UpperCAmelCase,      lang=_UpperCAmelCase,      output_type='''dict''',      config=_UpperCAmelCase)
   UpperCamelCase     , UpperCamelCase     , UpperCamelCase     , UpperCamelCase     , UpperCamelCase       =  data['''text'''], data['''left'''], data['''top'''], data['''width'''], data['''height''']

   # filter empty words and corresponding coordinates
   UpperCamelCase       =  [idx for idx, word in enumerate(_UpperCAmelCase) if not word.strip()]
   UpperCamelCase       =  [word for idx, word in enumerate(_UpperCAmelCase) if idx not in irrelevant_indices]
   UpperCamelCase       =  [coord for idx, coord in enumerate(_UpperCAmelCase) if idx not in irrelevant_indices]
   UpperCamelCase       =  [coord for idx, coord in enumerate(_UpperCAmelCase) if idx not in irrelevant_indices]
   UpperCamelCase       =  [coord for idx, coord in enumerate(_UpperCAmelCase) if idx not in irrelevant_indices]
   UpperCamelCase       =  [coord for idx, coord in enumerate(_UpperCAmelCase) if idx not in irrelevant_indices]

   # turn coordinates into (left, top, left+width, top+height) format
   UpperCamelCase       =  []
   for x, y, w, h in zip(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase):
      UpperCamelCase       =  [x, y, x + w, y + h]
      actual_boxes.append(_UpperCAmelCase)

   # finally, normalize the bounding boxes
   UpperCamelCase       =  []
   for box in actual_boxes:
      normalized_boxes.append(normalize_box(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase))

   assert len(_UpperCAmelCase) == len(_UpperCAmelCase), "Not as many words as there are bounding boxes"

   return words, normalized_boxes


class 						lowercase__	(  snake_case_   ):






   '''simple docstring'''







   _snake_case		   =							['''pixel_values''']







   def __init__(			self ,   lowerCamelCase__ = True ,   lowerCamelCase__ = None ,   lowerCamelCase__ = PILImageResampling.BILINEAR ,   lowerCamelCase__ = True ,   lowerCamelCase__ = 1 / 2_5_5 ,   lowerCamelCase__ = True ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = True ,   lowerCamelCase__ = None ,   lowerCamelCase__ = "" ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      super().__init__(**lowerCamelCase__   )
      UpperCamelCase       =  size if size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
      UpperCamelCase       =  get_size_dict(lowerCamelCase__   )

      UpperCamelCase       =  do_resize
      UpperCamelCase       =  size
      UpperCamelCase       =  resample
      UpperCamelCase       =  do_rescale
      UpperCamelCase       =  rescale_value
      UpperCamelCase       =  do_normalize
      UpperCamelCase       =  image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      UpperCamelCase       =  image_std if image_std is not None else IMAGENET_STANDARD_STD
      UpperCamelCase       =  apply_ocr
      UpperCamelCase       =  ocr_lang
      UpperCamelCase       =  tesseract_config







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ = PILImageResampling.BILINEAR ,   lowerCamelCase__ = None ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      UpperCamelCase       =  get_size_dict(lowerCamelCase__   )
      if "height" not in size or "width" not in size:
         raise ValueError(f'The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}'   )
      UpperCamelCase       =  (size['''height'''], size['''width'''])
      return resize(lowerCamelCase__ ,   size=lowerCamelCase__ ,   resample=lowerCamelCase__ ,   data_format=lowerCamelCase__ ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ = None ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      return rescale(lowerCamelCase__ ,   scale=lowerCamelCase__ ,   data_format=lowerCamelCase__ ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ = None ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      return normalize(lowerCamelCase__ ,   mean=lowerCamelCase__ ,   std=lowerCamelCase__ ,   data_format=lowerCamelCase__ ,   **lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__=None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = None ,   lowerCamelCase__ = ChannelDimension.FIRST ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      UpperCamelCase       =  do_resize if do_resize is not None else self.do_resize
      UpperCamelCase       =  size if size is not None else self.size
      UpperCamelCase       =  get_size_dict(lowerCamelCase__   )
      UpperCamelCase       =  resample if resample is not None else self.resample
      UpperCamelCase       =  do_rescale if do_rescale is not None else self.do_rescale
      UpperCamelCase       =  rescale_factor if rescale_factor is not None else self.rescale_factor
      UpperCamelCase       =  do_normalize if do_normalize is not None else self.do_normalize
      UpperCamelCase       =  image_mean if image_mean is not None else self.image_mean
      UpperCamelCase       =  image_std if image_std is not None else self.image_std
      UpperCamelCase       =  apply_ocr if apply_ocr is not None else self.apply_ocr
      UpperCamelCase       =  ocr_lang if ocr_lang is not None else self.ocr_lang
      UpperCamelCase       =  tesseract_config if tesseract_config is not None else self.tesseract_config

      UpperCamelCase       =  make_list_of_images(lowerCamelCase__   )

      if not valid_images(lowerCamelCase__   ):
         raise ValueError(
             '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
             '''torch.Tensor, tf.Tensor or jax.ndarray.'''   )

      if do_resize and size is None:
         raise ValueError('''Size must be specified if do_resize is True.'''   )

      if do_rescale and rescale_factor is None:
         raise ValueError('''Rescale factor must be specified if do_rescale is True.'''   )

      if do_normalize and (image_mean is None or image_std is None):
         raise ValueError('''If do_normalize is True, image_mean and image_std must be specified.'''   )

      # All transformations expect numpy arrays.
      UpperCamelCase       =  [to_numpy_array(lowerCamelCase__   ) for image in images]

      # Tesseract OCR to get words + normalized bounding boxes
      if apply_ocr:
         requires_backends(self ,   '''pytesseract'''   )
         UpperCamelCase       =  []
         UpperCamelCase       =  []
         for image in images:
            UpperCamelCase     , UpperCamelCase       =  apply_tesseract(lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   )
            words_batch.append(lowerCamelCase__   )
            boxes_batch.append(lowerCamelCase__   )

      if do_resize:
         UpperCamelCase       =  [self.resize(image=lowerCamelCase__ ,   size=lowerCamelCase__ ,   resample=lowerCamelCase__   ) for image in images]

      if do_rescale:
         UpperCamelCase       =  [self.rescale(image=lowerCamelCase__ ,   scale=lowerCamelCase__   ) for image in images]

      if do_normalize:
         UpperCamelCase       =  [self.normalize(image=lowerCamelCase__ ,   mean=lowerCamelCase__ ,   std=lowerCamelCase__   ) for image in images]

      UpperCamelCase       =  [to_channel_dimension_format(lowerCamelCase__ ,   lowerCamelCase__   ) for image in images]

      UpperCamelCase       =  BatchFeature(data={'''pixel_values''': images} ,   tensor_type=lowerCamelCase__   )

      if apply_ocr:
         UpperCamelCase       =  words_batch
         UpperCamelCase       =  boxes_batch
      return data





