
'''simple docstring'''


import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class 						lowercase__	(  snake_case_,					snake_case_,					unittest.TestCase   ):






   '''simple docstring'''







   _snake_case		   =							VQModel
   _snake_case		   =							'''sample'''







   @property
   def       UpperCAmelCase				(			self ,   lowerCamelCase__=(3_2, 3_2)   ):

      '''simple docstring'''







      UpperCamelCase       =  4
      UpperCamelCase       =  3

      UpperCamelCase       =  floats_tensor((batch_size, num_channels) + sizes   ).to(lowerCamelCase__   )

      return {"sample": image}







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return (3, 3_2, 3_2)







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return (3, 3_2, 3_2)







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  {
          '''block_out_channels''': [3_2, 6_4],
          '''in_channels''': 3,
          '''out_channels''': 3,
          '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
          '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
          '''latent_channels''': 3,
      }
      UpperCamelCase       =  self.dummy_input
      return init_dict, inputs_dict







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase     , UpperCamelCase       =  VQModel.from_pretrained('''fusing/vqgan-dummy''' ,   output_loading_info=lowerCamelCase__   )
      self.assertIsNotNone(lowerCamelCase__   )
      self.assertEqual(len(loading_info['''missing_keys''']   ) ,   0   )

      model.to(lowerCamelCase__   )
      UpperCamelCase       =  model(**self.dummy_input   )

      assert image is not None, "Make sure output is not None"







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  VQModel.from_pretrained('''fusing/vqgan-dummy'''   )
      model.to(lowerCamelCase__   ).eval()

      torch.manual_seed(0   )
      if torch.cuda.is_available():
         torch.cuda.manual_seed_all(0   )

      UpperCamelCase       =  torch.randn(1 ,   model.config.in_channels ,   model.config.sample_size ,   model.config.sample_size   )
      UpperCamelCase       =  image.to(lowerCamelCase__   )
      with torch.no_grad():
         UpperCamelCase       =  model(lowerCamelCase__   ).sample

      UpperCamelCase       =  output[0, -1, -3:, -3:].flatten().cpu()
      # fmt: off
      UpperCamelCase       =  torch.tensor([-0.0153, -0.4044, -0.1880, -0.5161, -0.2418, -0.4072, -0.1612, -0.0633, -0.0143]   )
      # fmt: on
      self.assertTrue(torch.allclose(lowerCamelCase__ ,   lowerCamelCase__ ,   atol=1e-3   )   )







'''simple docstring'''


import math
from typing import Optional

import numpy as np

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


snake_case_ :  Dict     =					logging.get_logger(__name__)

snake_case_ :  Union[str, Any]     =					{
    '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 						lowercase__	(  snake_case_   ):






   '''simple docstring'''







   _snake_case		   =							'''encodec'''







   def __init__(			self ,   lowerCamelCase__=[1.5, 3.0, 6.0, 12.0, 24.0] ,   lowerCamelCase__=2_4_0_0_0 ,   lowerCamelCase__=1 ,   lowerCamelCase__=False ,   lowerCamelCase__=None ,   lowerCamelCase__=None ,   lowerCamelCase__=1_2_8 ,   lowerCamelCase__=3_2 ,   lowerCamelCase__=1 ,   lowerCamelCase__=[8, 5, 4, 2] ,   lowerCamelCase__="weight_norm" ,   lowerCamelCase__=7 ,   lowerCamelCase__=7 ,   lowerCamelCase__=3 ,   lowerCamelCase__=2 ,   lowerCamelCase__=True ,   lowerCamelCase__="reflect" ,   lowerCamelCase__=2 ,   lowerCamelCase__=2 ,   lowerCamelCase__=1.0 ,   lowerCamelCase__=1_0_2_4 ,   lowerCamelCase__=None ,   lowerCamelCase__=True ,   **lowerCamelCase__ ,   ):

      '''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__(**lowerCamelCase__   )







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      if self.chunk_length_s is None:
         return None
      else:
         return int(self.chunk_length_s * self.sampling_rate   )







   @property
   def       UpperCAmelCase				(			self   ):

      '''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       UpperCAmelCase				(			self   ):

      '''simple docstring'''







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







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return int(1_0_0_0 * self.target_bandwidths[-1] // (self.frame_rate * 1_0)   )





