


"""simple docstring"""



import itertools
import random
import unittest

import numpy as np

from transformers import WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST, WavaVecaConfig, WavaVecaFeatureExtractor
from transformers.testing_utils import require_torch, slow

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


__snake_case       =       random.Random()







def     __lowerCAmelCase		(		lowercase    :    Optional[int]		,				lowercase    :    int=1.0		,				lowercase    :    Optional[Any]=None		,				lowercase    :    Optional[int]=None					)      ->		Any:


    """simple docstring"""





    if rng is None:
        snake_case       : Optional[Any]    =       global_rng

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

    return values







class _lowerCAmelCase							( unittest.TestCase      ):







   def __init__(      self		,      UpperCamelCase__		,      UpperCamelCase__=7		,      UpperCamelCase__=400		,      UpperCamelCase__=2000		,      UpperCamelCase__=1		,      UpperCamelCase__=0.0		,      UpperCamelCase__=1_6000		,      UpperCamelCase__=True		,      UpperCamelCase__=True		,      )      ->						List[Any]:

       '''simple docstring'''




       snake_case       : Any    =       parent
       snake_case       : Union[str, Any]    =       batch_size
       snake_case       : List[Any]    =       min_seq_length
       snake_case       : Optional[Any]    =       max_seq_length
       snake_case       : str    =       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       snake_case       : str    =       feature_size
       snake_case       : Union[str, Any]    =       padding_value
       snake_case       : List[Any]    =       sampling_rate
       snake_case       : List[Any]    =       return_attention_mask
       snake_case       : List[Any]    =       do_normalize







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

       '''simple docstring'''




       return {
           "feature_size": self.feature_size,
           "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		,      UpperCamelCase__=False		,      UpperCamelCase__=False		)      ->						Optional[Any]:

       '''simple docstring'''




       def _flatten(UpperCamelCase__		):
           return list(itertools.chain(*UpperCamelCase__		)		)

       if equal_length:
           snake_case       : Any    =       floats_list((self.batch_size, self.max_seq_length)		)
       else:
           # make sure that inputs increase in size
           snake_case       : int    =       [
               _flatten(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       : str    =       [np.asarray(UpperCamelCase__		) for x in speech_inputs]

       return speech_inputs







class _lowerCAmelCase							( snake_case_       ,				unittest.TestCase      ):
   __UpperCAmelCase					:			str				    =    WavaVecaFeatureExtractor







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       WavaVecaFeatureExtractionTester(self		)







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

       '''simple docstring'''




       self.assertTrue(np.all(np.mean(UpperCamelCase__		,      axis=0		) < 1e-3		)		)
       self.assertTrue(np.all(np.abs(np.var(UpperCamelCase__		,      axis=0		) - 1		) < 1e-3		)		)







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

       '''simple docstring'''




       snake_case       : Any    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       # create three inputs of length 800, 1000, and 1200
       snake_case       : Any    =       [floats_list((1, x)		)[0] for x in range(800		,      1400		,      200		)]
       snake_case       : Tuple    =       [np.asarray(UpperCamelCase__		) for speech_input in speech_inputs]

       # Test not batched input
       snake_case       : Tuple    =       feat_extract(speech_inputs[0]		,      return_tensors="np"		).input_values
       snake_case       : List[str]    =       feat_extract(np_speech_inputs[0]		,      return_tensors="np"		).input_values
       self.assertTrue(np.allclose(UpperCamelCase__		,      UpperCamelCase__		,      atol=1e-3		)		)

       # Test batched
       snake_case       : Tuple    =       feat_extract(UpperCamelCase__		,      return_tensors="np"		).input_values
       snake_case       : str    =       feat_extract(UpperCamelCase__		,      return_tensors="np"		).input_values
       for enc_seq_a, enc_seq_a in zip(UpperCamelCase__		,      UpperCamelCase__		):
           self.assertTrue(np.allclose(UpperCamelCase__		,      UpperCamelCase__		,      atol=1e-3		)		)

       # Test 2-D numpy arrays are batched.
       snake_case       : int    =       [floats_list((1, x)		)[0] for x in (800, 800, 800)]
       snake_case       : Dict    =       np.asarray(UpperCamelCase__		)
       snake_case       : Union[str, Any]    =       feat_extract(UpperCamelCase__		,      return_tensors="np"		).input_values
       snake_case       : List[str]    =       feat_extract(UpperCamelCase__		,      return_tensors="np"		).input_values
       for enc_seq_a, enc_seq_a in zip(UpperCamelCase__		,      UpperCamelCase__		):
           self.assertTrue(np.allclose(UpperCamelCase__		,      UpperCamelCase__		,      atol=1e-3		)		)







   def 					lowerCamelCase						(      self		)      ->						Optional[int]:

       '''simple docstring'''




       snake_case       : Tuple    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       snake_case       : int    =       [floats_list((1, x)		)[0] for x in range(800		,      1400		,      200		)]

       snake_case       : Union[str, Any]    =       ["longest", "max_length", "do_not_pad"]
       snake_case       : str    =       [None, 1600, None]
       for max_length, padding in zip(UpperCamelCase__		,      UpperCamelCase__		):
           snake_case       : Optional[Any]    =       feat_extract(UpperCamelCase__		,      padding=UpperCamelCase__		,      max_length=UpperCamelCase__		,      return_tensors="np"		)
           snake_case       : List[Any]    =       processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:800]		)
           self.assertTrue(input_values[0][800:].sum() < 1e-6		)
           self._check_zero_mean_unit_variance(input_values[1][:1000]		)
           self.assertTrue(input_values[0][1000:].sum() < 1e-6		)
           self._check_zero_mean_unit_variance(input_values[2][:1200]		)







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

       '''simple docstring'''




       snake_case       : str    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       snake_case       : List[str]    =       range(800		,      1400		,      200		)
       snake_case       : List[str]    =       [floats_list((1, x)		)[0] for x in lengths]

       snake_case       : Tuple    =       ["longest", "max_length", "do_not_pad"]
       snake_case       : int    =       [None, 1600, None]

       for max_length, padding in zip(UpperCamelCase__		,      UpperCamelCase__		):
           snake_case       : Optional[int]    =       feat_extract(UpperCamelCase__		,      max_length=UpperCamelCase__		,      padding=UpperCamelCase__		)
           snake_case       : List[str]    =       processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:800]		)
           self._check_zero_mean_unit_variance(input_values[1][:1000]		)
           self._check_zero_mean_unit_variance(input_values[2][:1200]		)







   def 					lowerCamelCase						(      self		)      ->						Optional[int]:

       '''simple docstring'''




       snake_case       : int    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       snake_case       : Union[str, Any]    =       [floats_list((1, x)		)[0] for x in range(800		,      1400		,      200		)]
       snake_case       : int    =       feat_extract(
           UpperCamelCase__		,      truncation=UpperCamelCase__		,      max_length=1000		,      padding="max_length"		,      return_tensors="np"		)
       snake_case       : str    =       processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :800]		)
       self._check_zero_mean_unit_variance(input_values[1]		)
       self._check_zero_mean_unit_variance(input_values[2]		)







   def 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       snake_case       : Union[str, Any]    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       snake_case       : str    =       [floats_list((1, x)		)[0] for x in range(800		,      1400		,      200		)]
       snake_case       : Tuple    =       feat_extract(
           UpperCamelCase__		,      truncation=UpperCamelCase__		,      max_length=1000		,      padding="longest"		,      return_tensors="np"		)
       snake_case       : Optional[int]    =       processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :800]		)
       self._check_zero_mean_unit_variance(input_values[1, :1000]		)
       self._check_zero_mean_unit_variance(input_values[2]		)

       # make sure that if max_length < longest -> then pad to max_length
       self.assertTrue(input_values.shape == (3, 1000)		)

       snake_case       : Union[str, Any]    =       [floats_list((1, x)		)[0] for x in range(800		,      1400		,      200		)]
       snake_case       : Tuple    =       feat_extract(
           UpperCamelCase__		,      truncation=UpperCamelCase__		,      max_length=2000		,      padding="longest"		,      return_tensors="np"		)
       snake_case       : Optional[Any]    =       processed.input_values

       self._check_zero_mean_unit_variance(input_values[0, :800]		)
       self._check_zero_mean_unit_variance(input_values[1, :1000]		)
       self._check_zero_mean_unit_variance(input_values[2]		)

       # make sure that if max_length > longest -> then pad to longest
       self.assertTrue(input_values.shape == (3, 1200)		)







   @require_torch
   def 					lowerCamelCase						(      self		)      ->						List[Any]:

       '''simple docstring'''




       import torch

       snake_case       : List[str]    =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
       snake_case       : Tuple    =       np.random.rand(100		).astype(np.floataa		)
       snake_case       : Tuple    =       np_speech_inputs.tolist()

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







   @slow
   @require_torch
   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




       for model_id in WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST:
           snake_case       : Tuple    =       WavaVecaConfig.from_pretrained(UpperCamelCase__		)
           snake_case       : Dict    =       WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__		)

           # only "layer" feature extraction norm should make use of
           # attention_mask
           self.assertEqual(feat_extract.return_attention_mask		,      config.feat_extract_norm == "layer"		)









"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__snake_case       =       {
    """configuration_bigbird_pegasus""": [
        """BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BigBirdPegasusConfig""",
        """BigBirdPegasusOnnxConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __snake_case       =       [
      """BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """BigBirdPegasusForCausalLM""",
      """BigBirdPegasusForConditionalGeneration""",
      """BigBirdPegasusForQuestionAnswering""",
      """BigBirdPegasusForSequenceClassification""",
      """BigBirdPegasusModel""",
      """BigBirdPegasusPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_bigbird_pegasus import (
      BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
      BigBirdPegasusConfig,
      BigBirdPegasusOnnxConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_bigbird_pegasus import (
        BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
        BigBirdPegasusForCausalLM,
        BigBirdPegasusForConditionalGeneration,
        BigBirdPegasusForQuestionAnswering,
        BigBirdPegasusForSequenceClassification,
        BigBirdPegasusModel,
        BigBirdPegasusPreTrainedModel,
    )


else:
  import sys

  __snake_case       =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





