





'''simple docstring'''






import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
      from transformers import SpeechaTextFeatureExtractor

A__    :       List[Any]              =random.Random()
def        UpperCamelCase__				(		lowerCAmelCase							,     lowerCAmelCase=1.0							,     lowerCAmelCase=None							,     lowerCAmelCase=None  ):





      """simple docstring"""


      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       ):




      def __init__(      self      :			List[str]      ,      __snake_case      :			Union[str, Any]      ,      __snake_case      :			List[str]=7      ,      __snake_case      :			Optional[Any]=4_00      ,      __snake_case      :			Any=20_00      ,      __snake_case      :			Optional[Any]=24      ,      __snake_case      :			Union[str, Any]=24      ,      __snake_case      :			Union[str, Any]=0.0      ,      __snake_case      :			List[Any]=1_60_00      ,      __snake_case      :			int=True      ,      __snake_case      :			Tuple=True      ,      )    ->				Optional[int]:
            _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												=							num_mel_bins
            _lowerCAmelCase												=							padding_value
            _lowerCAmelCase												=							sampling_rate
            _lowerCAmelCase												=							return_attention_mask
            _lowerCAmelCase												=							do_normalize




      def     lowercase__   (      self      :			Optional[Any]  )    ->				Any:
            return {
                "feature_size": self.feature_size,
                "num_mel_bins": self.num_mel_bins,
                "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      :			Tuple      ,      __snake_case      :			Any=False      ,      __snake_case      :			Any=False  )    ->				Union[str, Any]:
            def _flatten(__snake_case      :			Tuple  ):
                  return list(itertools.chain(*__snake_case  )  )

            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(__snake_case  ) for x in speech_inputs]
            return speech_inputs




@require_torch
@require_torchaudio
class 			UpperCAmelCase					(      snake_case_							,		unittest.TestCase       ):
      _lowercase:      Any											=       SpeechaTextFeatureExtractor if is_speech_available() else None




      def     lowercase__   (      self      :			Any  )    ->				int:
            _lowerCAmelCase												=							SpeechaTextFeatureExtractionTester(self  )




      def     lowercase__   (      self      :			str      ,      __snake_case      :			Optional[Any]  )    ->				Dict:
            self.assertTrue(np.all(np.mean(__snake_case      ,      axis=0  ) < 1E-3  )  )
            self.assertTrue(np.all(np.abs(np.var(__snake_case      ,      axis=0  ) - 1  ) < 1E-3  )  )




      def     lowercase__   (      self      :			Tuple  )    ->				List[str]:
            # 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(8_00      ,      14_00      ,      2_00  )]
            _lowerCAmelCase												=							[np.asarray(__snake_case  ) for speech_input in speech_inputs]

            # Test feature size
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      padding=__snake_case      ,      return_tensors="""np"""  ).input_features
            self.assertTrue(input_features.ndim == 3  )
            self.assertTrue(input_features.shape[-1] == 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(__snake_case      ,      __snake_case      ,      atol=1E-3  )  )

            # Test batched
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      return_tensors="""np"""  ).input_features
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      return_tensors="""np"""  ).input_features
            for enc_seq_a, enc_seq_a in zip(__snake_case      ,      __snake_case  ):
                  self.assertTrue(np.allclose(__snake_case      ,      __snake_case      ,      atol=1E-3  )  )

            # Test 2-D numpy arrays are batched.
            _lowerCAmelCase												=							[floats_list((1, x)  )[0] for x in (8_00, 8_00, 8_00)]
            _lowerCAmelCase												=							np.asarray(__snake_case  )
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      return_tensors="""np"""  ).input_features
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      return_tensors="""np"""  ).input_features
            for enc_seq_a, enc_seq_a in zip(__snake_case      ,      __snake_case  ):
                  self.assertTrue(np.allclose(__snake_case      ,      __snake_case      ,      atol=1E-3  )  )




      def     lowercase__   (      self      :			List[Any]  )    ->				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(8_00      ,      14_00      ,      2_00  )]

            _lowerCAmelCase												=							["""longest""", """max_length""", """do_not_pad"""]
            _lowerCAmelCase												=							[None, 16, None]
            for max_length, padding in zip(__snake_case      ,      __snake_case  ):
                  _lowerCAmelCase												=							feature_extractor(
                      __snake_case      ,      padding=__snake_case      ,      max_length=__snake_case      ,      return_attention_mask=__snake_case  )
                  _lowerCAmelCase												=							inputs.input_features
                  _lowerCAmelCase												=							inputs.attention_mask
                  _lowerCAmelCase												=							[np.sum(__snake_case  ) for x in attention_mask]

                  self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]  )
                  self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]  )
                  self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]  )




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				Tuple:
            _lowerCAmelCase												=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
            _lowerCAmelCase												=							[floats_list((1, x)  )[0] for x in range(8_00      ,      14_00      ,      2_00  )]

            _lowerCAmelCase												=							["""longest""", """max_length""", """do_not_pad"""]
            _lowerCAmelCase												=							[None, 16, None]
            for max_length, padding in zip(__snake_case      ,      __snake_case  ):
                  _lowerCAmelCase												=							feature_extractor(
                      __snake_case      ,      max_length=__snake_case      ,      padding=__snake_case      ,      return_tensors="""np"""      ,      return_attention_mask=__snake_case  )
                  _lowerCAmelCase												=							inputs.input_features
                  _lowerCAmelCase												=							inputs.attention_mask
                  _lowerCAmelCase												=							[np.sum(__snake_case  ) for x in attention_mask]

                  self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]  )
                  self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6  )
                  self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]  )
                  self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6  )
                  self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]  )




      def     lowercase__   (      self      :			int  )    ->				Tuple:
            _lowerCAmelCase												=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
            _lowerCAmelCase												=							[floats_list((1, x)  )[0] for x in range(8_00      ,      14_00      ,      2_00  )]
            _lowerCAmelCase												=							feature_extractor(
                __snake_case      ,      padding="""max_length"""      ,      max_length=4      ,      truncation=__snake_case      ,      return_tensors="""np"""      ,      return_attention_mask=__snake_case      ,      )
            _lowerCAmelCase												=							inputs.input_features
            _lowerCAmelCase												=							inputs.attention_mask
            _lowerCAmelCase												=							np.sum(attention_mask == 1      ,      axis=1  )

            self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]  )
            self._check_zero_mean_unit_variance(input_features[1]  )
            self._check_zero_mean_unit_variance(input_features[2]  )




      def     lowercase__   (      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(8_00      ,      14_00      ,      2_00  )]
            _lowerCAmelCase												=							feature_extractor(
                __snake_case      ,      padding="""longest"""      ,      max_length=4      ,      truncation=__snake_case      ,      return_tensors="""np"""      ,      return_attention_mask=__snake_case      ,      )
            _lowerCAmelCase												=							inputs.input_features
            _lowerCAmelCase												=							inputs.attention_mask
            _lowerCAmelCase												=							np.sum(attention_mask == 1      ,      axis=1  )

            self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]  )
            self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]  )
            self._check_zero_mean_unit_variance(input_features[2]  )

            # make sure that if max_length < longest -> then pad to max_length
            self.assertEqual(input_features.shape      ,      (3, 4, 24)  )

            _lowerCAmelCase												=							[floats_list((1, x)  )[0] for x in range(8_00      ,      14_00      ,      2_00  )]
            _lowerCAmelCase												=							feature_extractor(
                __snake_case      ,      padding="""longest"""      ,      max_length=16      ,      truncation=__snake_case      ,      return_tensors="""np"""      ,      return_attention_mask=__snake_case      ,      )
            _lowerCAmelCase												=							inputs.input_features
            _lowerCAmelCase												=							inputs.attention_mask
            _lowerCAmelCase												=							np.sum(attention_mask == 1      ,      axis=1  )

            self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]  )
            self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]  )
            self._check_zero_mean_unit_variance(input_features[2]  )

            # make sure that if max_length < longest -> then pad to max_length
            self.assertEqual(input_features.shape      ,      (3, 6, 24)  )




      def     lowercase__   (      self      :			int  )    ->				List[str]:
            import torch

            _lowerCAmelCase												=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
            _lowerCAmelCase												=							np.random.rand(1_00      ,      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      :			Any      ,      __snake_case      :			Union[str, Any]  )    ->				Any:
            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(__snake_case  )  )[:num_samples]["""audio"""]

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




      def     lowercase__   (      self      :			Tuple  )    ->				Optional[Any]:
            # fmt: off
            _lowerCAmelCase												=							np.array([
                -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
                -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
                -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
            ]  )
            # fmt: on

            _lowerCAmelCase												=							self._load_datasamples(1  )
            _lowerCAmelCase												=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
            _lowerCAmelCase												=							feature_extractor(__snake_case      ,      return_tensors="""pt"""  ).input_features
            self.assertEquals(input_features.shape      ,      (1, 5_84, 24)  )
            self.assertTrue(np.allclose(input_features[0, 0, :30]      ,      __snake_case      ,      atol=1E-4  )  )













'''simple docstring'''






import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property




@unittest.skipUnless(os.path.exists(snake_case_       )							,		'''Tatoeba directory does not exist.'''       )
class 			UpperCAmelCase					(      unittest.TestCase       ):




      @cached_property
      def     lowercase__   (      self      :			int  )    ->				Any:
            _lowerCAmelCase												=							tempfile.mkdtemp()
            return TatoebaConverter(save_dir=__snake_case  )




      @slow
      def     lowercase__   (      self      :			Dict  )    ->				int:
            self.resolver.convert_models(["""heb-eng"""]  )




      @slow
      def     lowercase__   (      self      :			Optional[int]  )    ->				Tuple:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.resolver.write_model_card("""opus-mt-he-en"""      ,      dry_run=__snake_case  )
            assert mmeta["long_pair"] == "heb-eng"






