



"""simple docstring"""






import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text




def 			snake_case		(		lowerCAmelCase_	)						->				str:
  _snake_case   	=      []
  for line in lines:
    _snake_case   	=      re.sub(R'''#.*'''  ,						''''''  ,						lowerCAmelCase_	)  # remove comments
    if line:
      filtered_lines.append(lowerCAmelCase_	)
  _snake_case   	=      '''\n'''.join(lowerCAmelCase_	)

  # Make a hash from all this code
  _snake_case   	=      full_str.encode('''utf-8'''	)
  return shaaaa(lowerCAmelCase_	).hexdigest()


# get importable module names and hash for caching
snake_case   					=				{
    '''csv''': (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    '''json''': (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    '''pandas''': (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    '''parquet''': (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    '''arrow''': (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    '''text''': (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    '''imagefolder''': (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    '''audiofolder''': (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
snake_case   					=				{
    '''.csv''': ('''csv''', {}),
    '''.tsv''': ('''csv''', {'''sep''': '''\t'''}),
    '''.json''': ('''json''', {}),
    '''.jsonl''': ('''json''', {}),
    '''.parquet''': ('''parquet''', {}),
    '''.arrow''': ('''arrow''', {}),
    '''.txt''': ('''text''', {}),
}
_EXTENSION_TO_MODULE.update({ext: ('''imagefolder''', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('''imagefolder''', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ('''audiofolder''', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('''audiofolder''', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
snake_case   					=				{'''imagefolder''', '''audiofolder'''}

# Used to filter data files based on extensions given a module name
snake_case   					=				{}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
     _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append('''.zip''')







_MODULE_TO_EXTENSIONS["audiofolder"].append('''.zip''')










"""simple docstring"""






import itertools
import os
import random
import tempfile
import unittest

import numpy as np

from transformers import TvltFeatureExtractor, is_datasets_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_torch_available():
     import torch

if is_datasets_available():
     from datasets import load_dataset

snake_case   					=				random.Random()




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_=1.0  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None	)						->				List[str]:
  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



class     UpperCAmelCase    (	unittest.TestCase  ):



   def __init__(       self    :	Tuple							,       __lowerCamelCase    :	List[str]							,       __lowerCamelCase    :	Optional[Any]=7							,       __lowerCamelCase    :	List[Any]=4_0_0							,       __lowerCamelCase    :	Any=2_0_0_0							,       __lowerCamelCase    :	Any=2_0_4_8							,       __lowerCamelCase    :	Any=1_2_8							,       __lowerCamelCase    :	Any=1							,       __lowerCamelCase    :	Optional[int]=5_1_2							,       __lowerCamelCase    :	Tuple=3_0							,       __lowerCamelCase    :	List[Any]=4_4_1_0_0							,       ):



     """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   	=      spectrogram_length
     _snake_case   	=      feature_size
     _snake_case   	=      num_audio_channels
     _snake_case   	=      hop_length
     _snake_case   	=      chunk_length
     _snake_case   	=      sampling_rate



   def    __UpperCAmelCase    (       self    :	List[Any]				):



     """simple docstring"""
     return {
         "spectrogram_length": self.spectrogram_length,
         "feature_size": self.feature_size,
         "num_audio_channels": self.num_audio_channels,
         "hop_length": self.hop_length,
         "chunk_length": self.chunk_length,
         "sampling_rate": self.sampling_rate,
     }





   def    __UpperCAmelCase    (       self    :	Union[str, Any]							,       __lowerCamelCase    :	Any=False							,       __lowerCamelCase    :	int=False				):



     """simple docstring"""
     def _flatten(__lowerCamelCase    :	List[str]				):
       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     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE,unittest.TestCase  ):
   A__		:	Tuple           =  TvltFeatureExtractor



   def    __UpperCAmelCase    (       self    :	int				):



     """simple docstring"""
     _snake_case   	=      TvltFeatureExtractionTester(self				)



   def    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     _snake_case   	=      self.feature_extraction_class(**self.feat_extract_dict				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''spectrogram_length'''				)				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''feature_size'''				)				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''num_audio_channels'''				)				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''hop_length'''				)				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''chunk_length'''				)				)
     self.assertTrue(hasattr(__lowerCamelCase							,       '''sampling_rate'''				)				)



   def    __UpperCAmelCase    (       self    :	int				):



     """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   	=      dict_first.pop('''mel_filters'''				)
     _snake_case   	=      dict_second.pop('''mel_filters'''				)
     self.assertTrue(np.allclose(__lowerCamelCase							,       __lowerCamelCase				)				)
     self.assertEqual(__lowerCamelCase							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	int				):



     """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   	=      dict_first.pop('''mel_filters'''				)
     _snake_case   	=      dict_second.pop('''mel_filters'''				)
     self.assertTrue(np.allclose(__lowerCamelCase							,       __lowerCamelCase				)				)
     self.assertEqual(__lowerCamelCase							,       __lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     # Initialize feature_extractor
     _snake_case   	=      self.feature_extraction_class(**self.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 not batched input
     _snake_case   	=      feature_extractor(np_speech_inputs[0]							,       return_tensors='''np'''							,       sampling_rate=4_4_1_0_0				).audio_values

     self.assertTrue(encoded_audios.ndim == 4				)
     self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size				)
     self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length				)
     self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels				)

     # Test batched
     _snake_case   	=      feature_extractor(__lowerCamelCase							,       return_tensors='''np'''							,       sampling_rate=4_4_1_0_0				).audio_values

     self.assertTrue(encoded_audios.ndim == 4				)
     self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size				)
     self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length				)
     self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels				)

     # Test audio masking
     _snake_case   	=      feature_extractor(
         __lowerCamelCase							,       return_tensors='''np'''							,       sampling_rate=4_4_1_0_0							,       mask_audio=__lowerCamelCase				).audio_values

     self.assertTrue(encoded_audios.ndim == 4				)
     self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size				)
     self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length				)
     self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels				)

     # 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'''							,       sampling_rate=4_4_1_0_0				).audio_values
     self.assertTrue(encoded_audios.ndim == 4				)
     self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size				)
     self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length				)
     self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels				)



   def    __UpperCAmelCase    (       self    :	Union[str, Any]							,       __lowerCamelCase    :	Optional[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    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      self._load_datasamples(1				)
     _snake_case   	=      TvltFeatureExtractor()
     _snake_case   	=      feature_extractor(__lowerCamelCase							,       return_tensors='''pt'''				).audio_values

     self.assertEquals(audio_values.shape							,       (1, 1, 1_9_2, 1_2_8)				)

     _snake_case   	=      torch.tensor([[-0.3_0_3_2, -0.2_7_0_8], [-0.4_4_3_4, -0.4_0_0_7]]				)
     self.assertTrue(torch.allclose(audio_values[0, 0, :2, :2]							,       __lowerCamelCase							,       atol=1E-4				)				)





