


from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)


@flax.struct.dataclass
class      __lowerCAmelCase  (			a       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							42
  _SCREAMING_SNAKE_CASE		     =							42






class      __lowerCAmelCase  (			nn.Module       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							42
  _SCREAMING_SNAKE_CASE		     =							(16, 32, 96, 256)
  _SCREAMING_SNAKE_CASE		     =							jnp.floataa



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			Any:




     """simple docstring"""
     snake_case_            =       nn.Conv(
         self.block_out_channels[0]     ,					kernel_size=(3, 3)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)

     snake_case_            =       []
     for i in range(len(self.block_out_channels	) - 1	):
        snake_case_            =       self.block_out_channels[i]
        snake_case_            =       self.block_out_channels[i + 1]
        snake_case_            =       nn.Conv(
            _lowerCAmelCase     ,					kernel_size=(3, 3)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)
        blocks.append(_lowerCAmelCase	)
        snake_case_            =       nn.Conv(
            _lowerCAmelCase     ,					kernel_size=(3, 3)     ,					strides=(2, 2)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)
        blocks.append(_lowerCAmelCase	)
     snake_case_            =       blocks

     snake_case_            =       nn.Conv(
         self.conditioning_embedding_channels     ,					kernel_size=(3, 3)     ,					padding=((1, 1), (1, 1))     ,					kernel_init=nn.initializers.zeros_init()     ,					bias_init=nn.initializers.zeros_init()     ,					dtype=self.dtype     ,					)



  def __call__(  self							:							Optional[int]     ,					_lowerCAmelCase							:							str	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       self.conv_in(_lowerCAmelCase	)
     snake_case_            =       nn.silu(_lowerCAmelCase	)

     for block in self.blocks:
        snake_case_            =       block(_lowerCAmelCase	)
        snake_case_            =       nn.silu(_lowerCAmelCase	)

     snake_case_            =       self.conv_out(_lowerCAmelCase	)

     return embedding






@flax_register_to_config
class      __lowerCAmelCase  (			nn.Module			,	a			,	a       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							32
  _SCREAMING_SNAKE_CASE		     =							4
  _SCREAMING_SNAKE_CASE		     =							(
      "CrossAttnDownBlock2D",
      "CrossAttnDownBlock2D",
      "CrossAttnDownBlock2D",
      "DownBlock2D",
  )
  _SCREAMING_SNAKE_CASE		     =							False
  _SCREAMING_SNAKE_CASE		     =							(320, 640, 1280, 1280)
  _SCREAMING_SNAKE_CASE		     =							2
  _SCREAMING_SNAKE_CASE		     =							8
  _SCREAMING_SNAKE_CASE		     =							None
  _SCREAMING_SNAKE_CASE		     =							1280
  _SCREAMING_SNAKE_CASE		     =							0.0
  _SCREAMING_SNAKE_CASE		     =							False
  _SCREAMING_SNAKE_CASE		     =							jnp.floataa
  _SCREAMING_SNAKE_CASE		     =							True
  _SCREAMING_SNAKE_CASE		     =							0
  _SCREAMING_SNAKE_CASE		     =							"rgb"
  _SCREAMING_SNAKE_CASE		     =							(16, 32, 96, 256)



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							jax.random.KeyArray	) ->			FrozenDict:




     """simple docstring"""
     # init input tensors
     snake_case_            =       (1, self.in_channels, self.sample_size, self.sample_size)
     snake_case_            =       jnp.zeros(_lowerCAmelCase     ,					dtype=jnp.floataa	)
     snake_case_            =       jnp.ones((1,)     ,					dtype=jnp.intaa	)
     snake_case_            =       jnp.zeros((1, 1, self.cross_attention_dim)     ,					dtype=jnp.floataa	)
     snake_case_            =       (1, 3, self.sample_size * 8, self.sample_size * 8)
     snake_case_            =       jnp.zeros(_lowerCAmelCase     ,					dtype=jnp.floataa	)

     snake_case_     ,     snake_case_            =       jax.random.split(_lowerCAmelCase	)
     snake_case_            =       {"params": params_rng, "dropout": dropout_rng}

     return self.init(_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase	)["params"]



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Dict:




     """simple docstring"""
     snake_case_            =       self.block_out_channels
     snake_case_            =       block_out_channels[0] * 4

     # If `num_attention_heads` is not defined (which is the case for most models)
     # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
     # The reason for this behavior is to correct for incorrectly named variables that were introduced
     # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
     # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
     # which is why we correct for the naming here.
     snake_case_            =       self.num_attention_heads or self.attention_head_dim

     # input
     snake_case_            =       nn.Conv(
         block_out_channels[0]     ,					kernel_size=(3, 3)     ,					strides=(1, 1)     ,					padding=((1, 1), (1, 1))     ,					dtype=self.dtype     ,					)

     # time
     snake_case_            =       FlaxTimesteps(
         block_out_channels[0]     ,					flip_sin_to_cos=self.flip_sin_to_cos     ,					freq_shift=self.config.freq_shift	)
     snake_case_            =       FlaxTimestepEmbedding(_lowerCAmelCase     ,					dtype=self.dtype	)

     snake_case_            =       FlaxControlNetConditioningEmbedding(
         conditioning_embedding_channels=block_out_channels[0]     ,					block_out_channels=self.conditioning_embedding_out_channels     ,					)

     snake_case_            =       self.only_cross_attention
     if isinstance(_lowerCAmelCase     ,					_lowerCAmelCase	):
        snake_case_            =       (only_cross_attention,) * len(self.down_block_types	)

     if isinstance(_lowerCAmelCase     ,					_lowerCAmelCase	):
        snake_case_            =       (num_attention_heads,) * len(self.down_block_types	)

     # down
     snake_case_            =       []
     snake_case_            =       []

     snake_case_            =       block_out_channels[0]

     snake_case_            =       nn.Conv(
         _lowerCAmelCase     ,					kernel_size=(1, 1)     ,					padding="VALID"     ,					kernel_init=nn.initializers.zeros_init()     ,					bias_init=nn.initializers.zeros_init()     ,					dtype=self.dtype     ,					)
     controlnet_down_blocks.append(_lowerCAmelCase	)

     for i, down_block_type in enumerate(self.down_block_types	):
        snake_case_            =       output_channel
        snake_case_            =       block_out_channels[i]
        snake_case_            =       i == len(_lowerCAmelCase	) - 1

        if down_block_type == "CrossAttnDownBlock2D":
           snake_case_            =       FlaxCrossAttnDownBlockaD(
               in_channels=_lowerCAmelCase     ,					out_channels=_lowerCAmelCase     ,					dropout=self.dropout     ,					num_layers=self.layers_per_block     ,					num_attention_heads=num_attention_heads[i]     ,					add_downsample=not is_final_block     ,					use_linear_projection=self.use_linear_projection     ,					only_cross_attention=only_cross_attention[i]     ,					dtype=self.dtype     ,					)
        else:
           snake_case_            =       FlaxDownBlockaD(
               in_channels=_lowerCAmelCase     ,					out_channels=_lowerCAmelCase     ,					dropout=self.dropout     ,					num_layers=self.layers_per_block     ,					add_downsample=not is_final_block     ,					dtype=self.dtype     ,					)

        down_blocks.append(_lowerCAmelCase	)

        for _ in range(self.layers_per_block	):
           snake_case_            =       nn.Conv(
               _lowerCAmelCase     ,					kernel_size=(1, 1)     ,					padding="VALID"     ,					kernel_init=nn.initializers.zeros_init()     ,					bias_init=nn.initializers.zeros_init()     ,					dtype=self.dtype     ,					)
           controlnet_down_blocks.append(_lowerCAmelCase	)

        if not is_final_block:
           snake_case_            =       nn.Conv(
               _lowerCAmelCase     ,					kernel_size=(1, 1)     ,					padding="VALID"     ,					kernel_init=nn.initializers.zeros_init()     ,					bias_init=nn.initializers.zeros_init()     ,					dtype=self.dtype     ,					)
           controlnet_down_blocks.append(_lowerCAmelCase	)

     snake_case_            =       down_blocks
     snake_case_            =       controlnet_down_blocks

     # mid
     snake_case_            =       block_out_channels[-1]
     snake_case_            =       FlaxUNetMidBlockaDCrossAttn(
         in_channels=_lowerCAmelCase     ,					dropout=self.dropout     ,					num_attention_heads=num_attention_heads[-1]     ,					use_linear_projection=self.use_linear_projection     ,					dtype=self.dtype     ,					)

     snake_case_            =       nn.Conv(
         _lowerCAmelCase     ,					kernel_size=(1, 1)     ,					padding="VALID"     ,					kernel_init=nn.initializers.zeros_init()     ,					bias_init=nn.initializers.zeros_init()     ,					dtype=self.dtype     ,					)



  def __call__(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							float = 1.0     ,					_lowerCAmelCase							:							bool = True     ,					_lowerCAmelCase							:							bool = False     ,					) ->			Union[FlaxControlNetOutput, Tuple]:




     """simple docstring"""
     snake_case_            =       self.controlnet_conditioning_channel_order
     if channel_order == "bgr":
        snake_case_            =       jnp.flip(_lowerCAmelCase     ,					axis=1	)

     # 1. time
     if not isinstance(_lowerCAmelCase     ,					jnp.ndarray	):
        snake_case_            =       jnp.array([timesteps]     ,					dtype=jnp.intaa	)
     elif isinstance(_lowerCAmelCase     ,					jnp.ndarray	) and len(timesteps.shape	) == 0:
        snake_case_            =       timesteps.astype(dtype=jnp.floataa	)
        snake_case_            =       jnp.expand_dims(_lowerCAmelCase     ,					0	)

     snake_case_            =       self.time_proj(_lowerCAmelCase	)
     snake_case_            =       self.time_embedding(_lowerCAmelCase	)

     # 2. pre-process
     snake_case_            =       jnp.transpose(_lowerCAmelCase     ,					(0, 2, 3, 1)	)
     snake_case_            =       self.conv_in(_lowerCAmelCase	)

     snake_case_            =       jnp.transpose(_lowerCAmelCase     ,					(0, 2, 3, 1)	)
     snake_case_            =       self.controlnet_cond_embedding(_lowerCAmelCase	)
     sample += controlnet_cond

     # 3. down
     snake_case_            =       (sample,)
     for down_block in self.down_blocks:
        if isinstance(_lowerCAmelCase     ,					_lowerCAmelCase	):
           snake_case_     ,     snake_case_            =       down_block(_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase     ,					deterministic=not train	)
        else:
           snake_case_     ,     snake_case_            =       down_block(_lowerCAmelCase     ,					_lowerCAmelCase     ,					deterministic=not train	)
        down_block_res_samples += res_samples

     # 4. mid
     snake_case_            =       self.mid_block(_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase     ,					deterministic=not train	)

     # 5. contronet blocks
     snake_case_            =       ()
     for down_block_res_sample, controlnet_block in zip(_lowerCAmelCase     ,					self.controlnet_down_blocks	):
        snake_case_            =       controlnet_block(_lowerCAmelCase	)
        controlnet_down_block_res_samples += (down_block_res_sample,)

     snake_case_            =       controlnet_down_block_res_samples

     snake_case_            =       self.controlnet_mid_block(_lowerCAmelCase	)

     # 6. scaling
     snake_case_            =       [sample * conditioning_scale for sample in down_block_res_samples]
     mid_block_res_sample *= conditioning_scale

     if not return_dict:
        return (down_block_res_samples, mid_block_res_sample)

     return FlaxControlNetOutput(
         down_block_res_samples=_lowerCAmelCase     ,					mid_block_res_sample=_lowerCAmelCase	)








import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
   from transformers import WhisperFeatureExtractor

if is_torch_available():
   import torch

SCREAMING_SNAKE_CASE						:Optional[int]			=  random.Random()



def       _lowerCAmelCase    (				lowerCAmelCase_				:List[str]		,    lowerCAmelCase_				:Tuple=1.0		,    lowerCAmelCase_				:Optional[int]=None		,    lowerCAmelCase_				:List[Any]=None				)->Dict:
   '''simple docstring'''






   if rng is None:
      snake_case_            =       global_rng

   snake_case_            =       []
   for batch_idx in range(shape[0]				):
      values.append([]				)
      for _ in range(shape[1]				):
         values[-1].append(rng.random() * scale				)

   return values


@require_torch
@require_torchaudio
class      __lowerCAmelCase  (			unittest.TestCase       ):






  """simple docstring"""





  def __init__(  self							:							Optional[int]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							List[str]=7     ,					_lowerCAmelCase							:							List[Any]=4_0_0     ,					_lowerCAmelCase							:							Optional[Any]=2_0_0_0     ,					_lowerCAmelCase							:							Tuple=1_0     ,					_lowerCAmelCase							:							Optional[int]=1_6_0     ,					_lowerCAmelCase							:							List[Any]=8     ,					_lowerCAmelCase							:							List[Any]=0.0     ,					_lowerCAmelCase							:							Dict=4_0_0_0     ,					_lowerCAmelCase							:							str=False     ,					_lowerCAmelCase							:							List[str]=True     ,					) ->			str:




     """simple docstring"""
     snake_case_            =       parent
     snake_case_            =       batch_size
     snake_case_            =       min_seq_length
     snake_case_            =       max_seq_length
     snake_case_            =       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     snake_case_            =       padding_value
     snake_case_            =       sampling_rate
     snake_case_            =       return_attention_mask
     snake_case_            =       do_normalize
     snake_case_            =       feature_size
     snake_case_            =       chunk_length
     snake_case_            =       hop_length



  def        lowerCAmelCase__	(  self							:							int	) ->			str:




     """simple docstring"""
     return {
         "feature_size": self.feature_size,
         "hop_length": self.hop_length,
         "chunk_length": self.chunk_length,
         "padding_value": self.padding_value,
         "sampling_rate": self.sampling_rate,
         "return_attention_mask": self.return_attention_mask,
         "do_normalize": self.do_normalize,
     }



  def        lowerCAmelCase__	(  self							:							int     ,					_lowerCAmelCase							:							Optional[Any]=False     ,					_lowerCAmelCase							:							List[Any]=False	) ->			int:




     """simple docstring"""
     def _flatten(_lowerCAmelCase							:							Union[str, Any]	):
        return list(itertools.chain(*_lowerCAmelCase	)	)

     if equal_length:
        snake_case_            =       [floats_list((self.max_seq_length, self.feature_size)	) for _ in range(self.batch_size	)]
     else:
        # make sure that inputs increase in size
        snake_case_            =       [
            floats_list((x, self.feature_size)	)
            for x in range(self.min_seq_length     ,					self.max_seq_length     ,					self.seq_length_diff	)
        ]
     if numpify:
        snake_case_            =       [np.asarray(_lowerCAmelCase	) for x in speech_inputs]
     return speech_inputs






@require_torch
@require_torchaudio
class      __lowerCAmelCase  (			a			,	unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							WhisperFeatureExtractor if is_speech_available() else None



  def        lowerCAmelCase__	(  self							:							str	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       WhisperFeatureExtractionTester(self	)



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       feat_extract_first.save_pretrained(_lowerCAmelCase	)[0]
        check_json_file_has_correct_format(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_pretrained(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			str:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       os.path.join(_lowerCAmelCase     ,					"feat_extract.json"	)
        feat_extract_first.to_json_file(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_json_file(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Any	) ->			Optional[int]:




     """simple docstring"""
     # Tests that all call wrap to encode_plus and batch_encode_plus
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     # create three inputs of length 800, 1000, and 1200
     snake_case_            =       [floats_list((1, x)	)[0] for x in range(8_0_0     ,					1_4_0_0     ,					2_0_0	)]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs]

     # Test feature size
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					padding="max_length"     ,					return_tensors="np"	).input_features
     self.assertTrue(input_features.ndim == 3	)
     self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames	)
     self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size	)

     # Test not batched input
     snake_case_            =       feature_extractor(speech_inputs[0]     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(np_speech_inputs[0]     ,					return_tensors="np"	).input_features
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test batched
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test 2-D numpy arrays are batched.
     snake_case_            =       [floats_list((1, x)	)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
     snake_case_            =       np.asarray(_lowerCAmelCase	)
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test truncation required
     snake_case_            =       [floats_list((1, x)	)[0] for x in range(2_0_0     ,					(feature_extractor.n_samples + 5_0_0)     ,					2_0_0	)]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs]

     snake_case_            =       [x[: feature_extractor.n_samples] for x in speech_inputs]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs_truncated]

     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)



  def        lowerCAmelCase__	(  self							:							Optional[int]	) ->			Tuple:




     """simple docstring"""
     import torch

     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       np.random.rand(1_0_0     ,					3_2	).astype(np.floataa	)
     snake_case_            =       np_speech_inputs.tolist()

     for inputs in [py_speech_inputs, np_speech_inputs]:
        snake_case_            =       feature_extractor.pad([{"input_features": inputs}]     ,					return_tensors="np"	)
        self.assertTrue(np_processed.input_features.dtype == np.floataa	)
        snake_case_            =       feature_extractor.pad([{"input_features": inputs}]     ,					return_tensors="pt"	)
        self.assertTrue(pt_processed.input_features.dtype == torch.floataa	)



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							Dict	) ->			int:




     """simple docstring"""
     snake_case_            =       load_dataset("hf-internal-testing/librispeech_asr_dummy"     ,					"clean"     ,					split="validation"	)
     # automatic decoding with librispeech
     snake_case_            =       ds.sort("id"	).select(range(_lowerCAmelCase	)	)[:num_samples]["audio"]

     return [x["array"] for x in speech_samples]



  def        lowerCAmelCase__	(  self							:							Optional[Any]	) ->			Optional[Any]:




     """simple docstring"""
     # fmt: off
     snake_case_            =       torch.tensor(
         [
             0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
             0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
             0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
             -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
         ]	)
     # fmt: on

     snake_case_            =       self._load_datasamples(1	)
     snake_case_            =       WhisperFeatureExtractor()
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="pt"	).input_features
     self.assertEqual(input_features.shape     ,					(1, 8_0, 3_0_0_0)	)
     self.assertTrue(torch.allclose(input_features[0, 0, :3_0]     ,					_lowerCAmelCase     ,					atol=1e-4	)	)



  def        lowerCAmelCase__	(  self							:							Union[str, Any]	) ->			List[str]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       self._load_datasamples(1	)[0]
     snake_case_            =       ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
     snake_case_            =       feat_extract.zero_mean_unit_var_norm([audio]     ,					attention_mask=_lowerCAmelCase	)[0]

     self.assertTrue(np.all(np.mean(_lowerCAmelCase	) < 1e-3	)	)
     self.assertTrue(np.all(np.abs(np.var(_lowerCAmelCase	) - 1	) < 1e-3	)	)




