






"""simple docstring"""





import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


_SCREAMING_SNAKE_CASE					:				Tuple					    =						random.Random()







def      lowerCamelCase__       (							_lowerCamelCase       :		List[Any]		,				_lowerCamelCase       :		List[Any]=1.0		,				_lowerCamelCase       :		Optional[int]=None		,				_lowerCamelCase       :		str=None )      ->				List[str]:
  if rng is None:
    lowerCamelCase_         =						global_rng

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

  return values






@require_torch
class      a						(					unittest.TestCase		):






    def __init__(       self     :							Any       ,						__SCREAMING_SNAKE_CASE     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							Tuple=7       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=400       ,						__SCREAMING_SNAKE_CASE     :							int=2000       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=1       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=0.0       ,						__SCREAMING_SNAKE_CASE     :							Dict=16000       ,						__SCREAMING_SNAKE_CASE     :							Dict=True       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=80       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=16       ,						__SCREAMING_SNAKE_CASE     :							int=64       ,						__SCREAMING_SNAKE_CASE     :							Tuple="hann_window"       ,						__SCREAMING_SNAKE_CASE     :							Dict=80       ,						__SCREAMING_SNAKE_CASE     :							List[str]=7600       ,						__SCREAMING_SNAKE_CASE     :							List[str]=1e-1_0       ,						__SCREAMING_SNAKE_CASE     :							Any=True       ,						)     ->		List[str]:
      lowerCamelCase_         =						parent
      lowerCamelCase_         =						batch_size
      lowerCamelCase_         =						min_seq_length
      lowerCamelCase_         =						max_seq_length
      lowerCamelCase_         =						(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      lowerCamelCase_         =						feature_size
      lowerCamelCase_         =						padding_value
      lowerCamelCase_         =						sampling_rate
      lowerCamelCase_         =						do_normalize
      lowerCamelCase_         =						num_mel_bins
      lowerCamelCase_         =						hop_length
      lowerCamelCase_         =						win_length
      lowerCamelCase_         =						win_function
      lowerCamelCase_         =						fmin
      lowerCamelCase_         =						fmax
      lowerCamelCase_         =						mel_floor
      lowerCamelCase_         =						return_attention_mask






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "do_normalize": self.do_normalize,
          "num_mel_bins": self.num_mel_bins,
          "hop_length": self.hop_length,
          "win_length": self.win_length,
          "win_function": self.win_function,
          "fmin": self.fmin,
          "fmax": self.fmax,
          "mel_floor": self.mel_floor,
          "return_attention_mask": self.return_attention_mask,
      }






    def    UpperCamelCase       (       self     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							Tuple=False       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=False					)     ->		str:
      def _flatten(__SCREAMING_SNAKE_CASE     :							Any					):
        return list(itertools.chain(*__SCREAMING_SNAKE_CASE					)					)

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

      return speech_inputs






    def    UpperCamelCase       (       self     :							Optional[int]       ,						__SCREAMING_SNAKE_CASE     :							str=False       ,						__SCREAMING_SNAKE_CASE     :							Any=False					)     ->		int:
      if equal_length:
        lowerCamelCase_         =						[floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
      else:
        # make sure that inputs increase in size
        lowerCamelCase_         =						[
            floats_list((x, self.num_mel_bins)					)
            for x in range(self.min_seq_length       ,						self.max_seq_length       ,						self.seq_length_diff					)
        ]

      if numpify:
        lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]

      return speech_inputs






@require_torch
class      a						(					__snake_case  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     Any						= SpeechTaFeatureExtractor






    def    UpperCamelCase       (       self     :							Any					)     ->		Any:
      lowerCamelCase_         =						SpeechTaFeatureExtractionTester(self					)






    def    UpperCamelCase       (       self     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							int					)     ->		List[Any]:
      self.assertTrue(np.all(np.mean(__SCREAMING_SNAKE_CASE       ,						axis=0					) < 1e-3					)					)
      self.assertTrue(np.all(np.abs(np.var(__SCREAMING_SNAKE_CASE       ,						axis=0					) - 1					) < 1e-3					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		int:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      # create three inputs of length 800, 1000, and 1200
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test not batched input
      lowerCamelCase_         =						feat_extract(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		Optional[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]
      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
        lowerCamelCase_         =						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    UpperCamelCase       (       self     :							Dict					)     ->		Dict:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						range(800       ,						1400       ,						200					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in lengths]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]

      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE					)
        lowerCamelCase_         =						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    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='max_length'       ,						return_tensors='np'					)
      lowerCamelCase_         =						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    UpperCamelCase       (       self     :							List[str]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						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)					)

      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=2000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						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)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						np.random.rand(100					).astype(np.floataa					)
      lowerCamelCase_         =						np_speech_inputs.tolist()

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






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Tuple:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      # create three inputs of length 800, 1000, and 1200
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test feature size
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      self.assertTrue(input_values.ndim == 3					)
      self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

      # Test not batched input
      lowerCamelCase_         =						feature_extractor(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test 2-D numpy arrays are batched.
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in (800, 800, 800)]
      lowerCamelCase_         =						np.asarray(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							int					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      self.assertTrue(all(len(__SCREAMING_SNAKE_CASE					) == len(__SCREAMING_SNAKE_CASE					) for x, y in zip(__SCREAMING_SNAKE_CASE       ,						processed_features[input_name]					)					)					)

      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='np'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							Tuple					)     ->		Any:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='pt'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)[input_name]
      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='pt'					)[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(list(processed.attention_mask.shape					)       ,						list(processed[input_name].shape[:2]					)					)
      self.assertListEqual(processed.attention_mask.sum(-1					).tolist()       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)
      lowerCamelCase_         =						min(__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(
          __SCREAMING_SNAKE_CASE       ,						padding='max_length'       ,						max_length=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(
          list(processed_pad.attention_mask.shape					)       ,						[processed_pad[input_name].shape[0], max_length]					)
      self.assertListEqual(
          processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()       ,						[max_length for x in speech_inputs]					)






    def    UpperCamelCase       (       self     :							Optional[Any]       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]					)     ->		List[str]:
      from datasets import load_dataset

      lowerCamelCase_         =						load_dataset('hf-internal-testing/librispeech_asr_dummy'       ,						'clean'       ,						split='validation'					)
      # automatic decoding with librispeech
      lowerCamelCase_         =						ds.sort('id'					).select(range(__SCREAMING_SNAKE_CASE					)					)[:num_samples]['audio']

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






    def    UpperCamelCase       (       self     :							str					)     ->		Dict:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
           3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
           2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
           4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
           7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
           4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 93680)					)
      self.assertTrue(torch.allclose(input_values[0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-6					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Optional[int]:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
           -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
           -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
           -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 366, 80)					)
      self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-4					)					)












"""simple docstring"""





import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


_SCREAMING_SNAKE_CASE					:				Any					    =						importlib.util.find_spec('''s3fs''') is not None

if _has_safs:
  from .safilesystem import SaFileSystem  # noqa: F401

_SCREAMING_SNAKE_CASE					:				List[compression.BaseCompressedFileFileSystem]					    =						[
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
  if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
    warnings.warn(F'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
  fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)







def      lowerCamelCase__       (							_lowerCamelCase       :		str )      ->				str:
  if "://" in dataset_path:
    lowerCamelCase_         =						dataset_path.split('://' )[1]
  return dataset_path







def      lowerCamelCase__       (							_lowerCamelCase       :		fsspec.AbstractFileSystem )      ->				bool:
  if fs is not None and fs.protocol != "file":
    return True
  else:
    return False







def      lowerCamelCase__       (							_lowerCamelCase       :		fsspec.AbstractFileSystem		,				_lowerCamelCase       :		str		,				_lowerCamelCase       :		str )      ->				int:
  lowerCamelCase_         =						not is_remote_filesystem(_lowerCamelCase )
  if is_local:
    # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
    shutil.move(fs._strip_protocol(_lowerCamelCase )		,				fs._strip_protocol(_lowerCamelCase ) )
  else:
    fs.mv(_lowerCamelCase		,				_lowerCamelCase		,				recursive=_lowerCamelCase )







def      lowerCamelCase__       (							)      ->				None:
  if hasattr(fsspec.asyn		,				'reset_lock' ):
    # for future fsspec>2022.05.0
    fsspec.asyn.reset_lock()
  else:
    lowerCamelCase_         =						None
    lowerCamelCase_         =						None
    lowerCamelCase_         =						threading.Lock()




