
'''simple docstring'''



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

_lowercase          =						random.Random()


def A (__lowerCamelCase :Tuple					,      __lowerCamelCase :int=1.0					,      __lowerCamelCase :Any=None					,      __lowerCamelCase :Tuple=None						):
						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
@require_torchaudio
class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						def __init__(   self       ,  _lowercase       ,  _lowercase=7       ,  _lowercase=400       ,  _lowercase=2_000       ,  _lowercase=10       ,  _lowercase=160       ,  _lowercase=8       ,  _lowercase=0.0       ,  _lowercase=4_000       ,  _lowercase=False       ,  _lowercase=True       ,  ):

												"""simple docstring"""



												_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    		=					padding_value
												_lowerCAmelCase    		=					sampling_rate
												_lowerCAmelCase    		=					return_attention_mask
												_lowerCAmelCase    		=					do_normalize
												_lowerCAmelCase    		=					feature_size
												_lowerCAmelCase    		=					chunk_length
												_lowerCAmelCase    		=					hop_length




						def    _lowercase      (   self ):

												"""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    _lowercase      (   self       ,  _lowercase=False       ,  _lowercase=False ):

												"""simple docstring"""



												def _flatten(_lowercase ):
																		return list(itertools.chain(*lowerCamelCase_ ) )

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






@require_torch
@require_torchaudio
class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE			,				unittest.TestCase					):






						'''simple docstring'''






						_lowercase						: str										=  WhisperFeatureExtractor if is_speech_available() else None




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					WhisperFeatureExtractionTester(self )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.feature_extraction_class(**self.feat_extract_dict )

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

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.feature_extraction_class(**self.feat_extract_dict )

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

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_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       ,  1_400       ,  200 )]
												_lowerCAmelCase    		=					[np.asarray(lowerCamelCase_ ) for speech_input in speech_inputs]

												# Test feature size
												_lowerCAmelCase    		=					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
												_lowerCAmelCase    		=					feature_extractor(speech_inputs[0]       ,  return_tensors="""np""" ).input_features
												_lowerCAmelCase    		=					feature_extractor(np_speech_inputs[0]       ,  return_tensors="""np""" ).input_features
												self.assertTrue(np.allclose(lowerCamelCase_       ,  lowerCamelCase_       ,  atol=1e-3 ) )

												# Test batched
												_lowerCAmelCase    		=					feature_extractor(lowerCamelCase_       ,  return_tensors="""np""" ).input_features
												_lowerCAmelCase    		=					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.
												_lowerCAmelCase    		=					[floats_list((1, x) )[0] for x in (800, 800, 800)]
												_lowerCAmelCase    		=					np.asarray(lowerCamelCase_ )
												_lowerCAmelCase    		=					feature_extractor(lowerCamelCase_       ,  return_tensors="""np""" ).input_features
												_lowerCAmelCase    		=					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
												_lowerCAmelCase    		=					[floats_list((1, x) )[0] for x in range(200       ,  (feature_extractor.n_samples + 500)       ,  200 )]
												_lowerCAmelCase    		=					[np.asarray(lowerCamelCase_ ) for speech_input in speech_inputs]

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

												_lowerCAmelCase    		=					feature_extractor(lowerCamelCase_       ,  return_tensors="""np""" ).input_features
												_lowerCAmelCase    		=					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    _lowercase      (   self ):

												"""simple docstring"""



												import torch

												_lowerCAmelCase    		=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
												_lowerCAmelCase    		=					np.random.rand(100       ,  32 ).astype(np.floataa )
												_lowerCAmelCase    		=					np_speech_inputs.tolist()

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




						def    _lowercase      (   self       ,  _lowercase ):

												"""simple docstring"""



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

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					torch.tensor(
												    [
												        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
												        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
												        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
												        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
												    ] )
												# fmt: on

												_lowerCAmelCase    		=					self._load_datasamples(1 )
												_lowerCAmelCase    		=					WhisperFeatureExtractor()
												_lowerCAmelCase    		=					feature_extractor(lowerCamelCase_       ,  return_tensors="""pt""" ).input_features
												self.assertEqual(input_features.shape       ,  (1, 80, 3_000) )
												self.assertTrue(torch.allclose(input_features[0, 0, :30]       ,  lowerCamelCase_       ,  atol=1e-4 ) )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
												_lowerCAmelCase    		=					self._load_datasamples(1 )[0]
												_lowerCAmelCase    		=					((audio - audio.min()) / (audio.max() - audio.min())) * 65_535  # Rescale to [0, 65535] to show issue
												_lowerCAmelCase    		=					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 ) )

'''simple docstring'''

from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate


@dataclass(frozen=lowerCAmelCase )
class 					_lowercase						(   lowerCAmelCase ):
      '''simple docstring'''


      UpperCAmelCase_   :   str   				= field(default='''question-answering-extractive'''		,metadata={'''include_in_asdict_even_if_is_default''': True} )
      UpperCAmelCase_   :   ClassVar[Features]   				= Features({'''question''': Value('''string''' ), '''context''': Value('''string''' )} )
      UpperCAmelCase_   :   ClassVar[Features]   				= Features(
          {
              '''answers''': Sequence(
                  {
                      '''text''': Value('''string''' ),
                      '''answer_start''': Value('''int32''' ),
                  } )
          } )
      UpperCAmelCase_   :   str   				= "question"
      UpperCAmelCase_   :   str   				= "context"
      UpperCAmelCase_   :   str   				= "answers"




      @property
      def 		lowerCAmelCase__       (					self				)      ->      Dict[str, str]:



         '''simple docstring'''



         return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}




