"""simple docstring"""







class  UpperCamelCase	:
   def __init__(    self    )			->   List[str]:


        '''simple docstring'''


        lowercase_			:       Union[str, Any]									=			''
        lowercase_			:       Any									=			''
        lowercase_			:       Tuple									=			[]
   def     _UpperCAmelCase     (    self  ,__UpperCamelCase  ,__UpperCamelCase    )			->   List[str]:


        '''simple docstring'''


        if m == -1:
             return n + 1
        elif n == -1:
             return m + 1
        elif self.dp[m][n] > -1:
             return self.dp[m][n]
        else:
             if self.worda[m] == self.worda[n]:
                  lowercase_			:       List[str]									=			self.__min_dist_top_down_dp(m - 1  ,n - 1    )
             else:
                  lowercase_			:       Any									=			self.__min_dist_top_down_dp(_lowercase  ,n - 1    )
                  lowercase_			:       Dict									=			self.__min_dist_top_down_dp(m - 1  ,_lowercase    )
                  lowercase_			:       Union[str, Any]									=			self.__min_dist_top_down_dp(m - 1  ,n - 1    )
                  lowercase_			:       Tuple									=			1 + min(_lowercase  ,_lowercase  ,_lowercase    )

             return self.dp[m][n]
   def     _UpperCAmelCase     (    self  ,__UpperCamelCase  ,__UpperCamelCase    )			->   Optional[Any]:


        '''simple docstring'''


        lowercase_			:       Optional[int]									=			worda
        lowercase_			:       Dict									=			worda
        lowercase_			:       Optional[int]									=			[[-1 for _ in range(len(_lowercase    )    )] for _ in range(len(_lowercase    )    )]

        return self.__min_dist_top_down_dp(len(_lowercase    ) - 1  ,len(_lowercase    ) - 1    )







   def     _UpperCAmelCase     (    self  ,__UpperCamelCase  ,__UpperCamelCase    )			->   Optional[int]:


        '''simple docstring'''


        lowercase_			:       Optional[Any]									=			worda
        lowercase_			:       List[Any]									=			worda
        lowercase_			:       int									=			len(_lowercase    )
        lowercase_			:       Dict									=			len(_lowercase    )
        lowercase_			:       int									=			[[0 for _ in range(n + 1    )] for _ in range(m + 1    )]

        for i in range(m + 1    ):
             for j in range(n + 1    ):
                  if i == 0:  # first string is empty
                       lowercase_			:       List[Any]									=			j
                  elif j == 0:  # second string is empty
                       lowercase_			:       List[str]									=			i
                  elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                       lowercase_			:       List[str]									=			self.dp[i - 1][j - 1]
                  else:
                       lowercase_			:       List[str]									=			self.dp[i][j - 1]
                       lowercase_			:       Optional[Any]									=			self.dp[i - 1][j]
                       lowercase_			:       Optional[int]									=			self.dp[i - 1][j - 1]
                       lowercase_			:       str									=			1 + min(_lowercase  ,_lowercase  ,_lowercase    )
        return self.dp[m][n]


if __name__ == "__main__":
       __SCREAMING_SNAKE_CASE								=EditDistance()

       print("****************** Testing Edit Distance DP Algorithm ******************")
       print()

       __SCREAMING_SNAKE_CASE								=input("Enter the first string: ").strip()
       __SCREAMING_SNAKE_CASE								=input("Enter the second string: ").strip()

       print()
       print(F"The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}")
       print(F"The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}")
       print()
       print("*************** End of Testing Edit Distance DP Algorithm ***************")
"""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

__SCREAMING_SNAKE_CASE								=random.Random()



def     lowercase__( __SCREAMING_SNAKE_CASE							:  Optional[int]  ,    __SCREAMING_SNAKE_CASE							:  Union[str, Any]=1.0  ,    __SCREAMING_SNAKE_CASE							:  Dict=None  ,    __SCREAMING_SNAKE_CASE							:  Tuple=None   ):
     if rng is None:
          lowercase_			:       Union[str, Any]									=			global_rng

     lowercase_			:       str									=			[]
     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						):
   def __init__(    self  ,__UpperCamelCase  ,__UpperCamelCase=7  ,__UpperCamelCase=400  ,__UpperCamelCase=2000  ,__UpperCamelCase=10  ,__UpperCamelCase=160  ,__UpperCamelCase=8  ,__UpperCamelCase=0.0  ,__UpperCamelCase=4000  ,__UpperCamelCase=False  ,__UpperCamelCase=True  ,)			->   List[str]:


        '''simple docstring'''


        lowercase_			:       Tuple									=			parent
        lowercase_			:       Optional[Any]									=			batch_size
        lowercase_			:       Optional[int]									=			min_seq_length
        lowercase_			:       List[Any]									=			max_seq_length
        lowercase_			:       Tuple									=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
        lowercase_			:       Tuple									=			padding_value
        lowercase_			:       Dict									=			sampling_rate
        lowercase_			:       List[str]									=			return_attention_mask
        lowercase_			:       str									=			do_normalize
        lowercase_			:       str									=			feature_size
        lowercase_			:       List[Any]									=			chunk_length
        lowercase_			:       Optional[int]									=			hop_length
   def     _UpperCAmelCase     (    self    )			->   List[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     _UpperCAmelCase     (    self  ,__UpperCamelCase=False  ,__UpperCamelCase=False    )			->   Union[str, Any]:


        '''simple docstring'''


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

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







@require_torch
@require_torchaudio
class  UpperCamelCase	(    lowercase_		,   unittest.TestCase						):
   lowercase							=						WhisperFeatureExtractor if is_speech_available() else None
   def     _UpperCAmelCase     (    self    )			->   Any:


        '''simple docstring'''


        lowercase_			:       int									=			WhisperFeatureExtractionTester(self    )
   def     _UpperCAmelCase     (    self    )			->   str:


        '''simple docstring'''


        lowercase_			:       Any									=			self.feature_extraction_class(**self.feat_extract_dict    )

        with tempfile.TemporaryDirectory() as tmpdirname:
             lowercase_			:       List[Any]									=			feat_extract_first.save_pretrained(__UpperCamelCase    )[0]
             check_json_file_has_correct_format(__UpperCamelCase    )
             lowercase_			:       Optional[Any]									=			self.feature_extraction_class.from_pretrained(__UpperCamelCase    )

        lowercase_			:       Optional[int]									=			feat_extract_first.to_dict()
        lowercase_			:       int									=			feat_extract_second.to_dict()
        lowercase_			:       List[Any]									=			feat_extract_first.mel_filters
        lowercase_			:       Tuple									=			feat_extract_second.mel_filters
        self.assertTrue(np.allclose(__UpperCamelCase  ,__UpperCamelCase    )    )
        self.assertEqual(__UpperCamelCase  ,__UpperCamelCase    )
   def     _UpperCAmelCase     (    self    )			->   Tuple:


        '''simple docstring'''


        lowercase_			:       Any									=			self.feature_extraction_class(**self.feat_extract_dict    )

        with tempfile.TemporaryDirectory() as tmpdirname:
             lowercase_			:       List[Any]									=			os.path.join(__UpperCamelCase  ,'feat_extract.json'    )
             feat_extract_first.to_json_file(__UpperCamelCase    )
             lowercase_			:       Dict									=			self.feature_extraction_class.from_json_file(__UpperCamelCase    )

        lowercase_			:       Optional[Any]									=			feat_extract_first.to_dict()
        lowercase_			:       Optional[Any]									=			feat_extract_second.to_dict()
        lowercase_			:       List[str]									=			feat_extract_first.mel_filters
        lowercase_			:       Tuple									=			feat_extract_second.mel_filters
        self.assertTrue(np.allclose(__UpperCamelCase  ,__UpperCamelCase    )    )
        self.assertEqual(__UpperCamelCase  ,__UpperCamelCase    )
   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


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

        # Test feature size
        lowercase_			:       Tuple									=			feature_extractor(__UpperCamelCase  ,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
        lowercase_			:       List[str]									=			feature_extractor(speech_inputs[0]  ,return_tensors='np'    ).input_features
        lowercase_			:       List[str]									=			feature_extractor(np_speech_inputs[0]  ,return_tensors='np'    ).input_features
        self.assertTrue(np.allclose(__UpperCamelCase  ,__UpperCamelCase  ,atol=1e-3    )    )

        # Test batched
        lowercase_			:       Dict									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        lowercase_			:       List[str]									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        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.
        lowercase_			:       List[Any]									=			[floats_list((1, x)    )[0] for x in (800, 800, 800)]
        lowercase_			:       Optional[int]									=			np.asarray(__UpperCamelCase    )
        lowercase_			:       List[str]									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        lowercase_			:       Dict									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        for enc_seq_a, enc_seq_a in zip(__UpperCamelCase  ,__UpperCamelCase    ):
             self.assertTrue(np.allclose(__UpperCamelCase  ,__UpperCamelCase  ,atol=1e-3    )    )

        # Test truncation required
        lowercase_			:       List[str]									=			[floats_list((1, x)    )[0] for x in range(200  ,(feature_extractor.n_samples + 500)  ,200    )]
        lowercase_			:       Union[str, Any]									=			[np.asarray(__UpperCamelCase    ) for speech_input in speech_inputs]

        lowercase_			:       Union[str, Any]									=			[x[: feature_extractor.n_samples] for x in speech_inputs]
        lowercase_			:       int									=			[np.asarray(__UpperCamelCase    ) for speech_input in speech_inputs_truncated]

        lowercase_			:       Tuple									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        lowercase_			:       Optional[Any]									=			feature_extractor(__UpperCamelCase  ,return_tensors='np'    ).input_features
        for enc_seq_a, enc_seq_a in zip(__UpperCamelCase  ,__UpperCamelCase    ):
             self.assertTrue(np.allclose(__UpperCamelCase  ,__UpperCamelCase  ,atol=1e-3    )    )
   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


        import torch

        lowercase_			:       Union[str, Any]									=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
        lowercase_			:       List[str]									=			np.random.rand(100  ,32    ).astype(np.floataa    )
        lowercase_			:       Any									=			np_speech_inputs.tolist()

        for inputs in [py_speech_inputs, np_speech_inputs]:
             lowercase_			:       Optional[Any]									=			feature_extractor.pad([{'input_features': inputs}]  ,return_tensors='np'    )
             self.assertTrue(np_processed.input_features.dtype == np.floataa    )
             lowercase_			:       Union[str, Any]									=			feature_extractor.pad([{'input_features': inputs}]  ,return_tensors='pt'    )
             self.assertTrue(pt_processed.input_features.dtype == torch.floataa    )
   def     _UpperCAmelCase     (    self  ,__UpperCamelCase    )			->   Tuple:


        '''simple docstring'''


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

        return [x["array"] for x in speech_samples]
   def     _UpperCAmelCase     (    self    )			->   int:


        '''simple docstring'''


        lowercase_			:       List[Any]									=			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

        lowercase_			:       Optional[int]									=			self._load_datasamples(1    )
        lowercase_			:       Dict									=			WhisperFeatureExtractor()
        lowercase_			:       str									=			feature_extractor(__UpperCamelCase  ,return_tensors='pt'    ).input_features
        self.assertEqual(input_features.shape  ,(1, 80, 3000)    )
        self.assertTrue(torch.allclose(input_features[0, 0, :30]  ,__UpperCamelCase  ,atol=1e-4    )    )







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


        '''simple docstring'''


        lowercase_			:       Dict									=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
        lowercase_			:       List[Any]									=			self._load_datasamples(1    )[0]
        lowercase_			:       Tuple									=			((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
        lowercase_			:       Tuple									=			feat_extract.zero_mean_unit_var_norm([audio]  ,attention_mask=__UpperCamelCase    )[0]

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

