code: 
  
  
  '''simple docstring'''
  
  
  
  
  import os
  
  from ...utils import logging
  from .utils import DataProcessor, InputExample
  
  
  __lowercase  :      str      		=				logging.get_logger(__name__)
  
  
  
  
  
  class _snake_case   ( a__   ):
         """simple docstring"""
  
  
  
  
  
         def __init__(   self			,				__A			,				__A=None	)     ->List[str]:
  
  
  
             """simple docstring"""
  
  
  
  
  
  
  
             __lowerCamelCase		:      str											=					language
             __lowerCamelCase		:      int											=					train_language
  
  
  
  
  
  
  
         def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->Tuple:
  
  
  
             """simple docstring"""
  
  
  
  
  
  
  
             __lowerCamelCase		:      List[str]											=					self.language if self.train_language is None else self.train_language
             __lowerCamelCase		:      Tuple											=					self._read_tsv(os.path.join(__A			,				f'XNLI-MT-1.0/multinli/multinli.train.{lg}.tsv'	)	)
             __lowerCamelCase		:      Tuple											=					[]
             for i, line in enumerate(__A	):
                 if i == 0:
                     continue
                 __lowerCamelCase		:      Optional[int]											=					f'train-{i}'
                 __lowerCamelCase		:      int											=					line[0]
                 __lowerCamelCase		:      Union[str, Any]											=					line[1]
                 __lowerCamelCase		:      Optional[Any]											=					"contradiction" if line[2] == "contradictory" else line[2]
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training input {text_a} is not a string'	)
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training input {text_b} is not a string'	)
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training label {label} is not a string'	)
                 examples.append(InputExample(guid=__A			,				text_a=__A			,				text_b=__A			,				label=__A	)	)
             return examples
  
  
  
  
  
  
  
         def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->Union[str, Any]:
  
  
  
             """simple docstring"""
  
  
  
  
  
  
  
             __lowerCamelCase		:      Union[str, Any]											=					self._read_tsv(os.path.join(__A			,				"XNLI-1.0/xnli.test.tsv"	)	)
             __lowerCamelCase		:      List[str]											=					[]
             for i, line in enumerate(__A	):
                 if i == 0:
                     continue
                 __lowerCamelCase		:      Union[str, Any]											=					line[0]
                 if language != self.language:
                     continue
                 __lowerCamelCase		:      str											=					f'test-{i}'
                 __lowerCamelCase		:      Dict											=					line[6]
                 __lowerCamelCase		:      List[Any]											=					line[7]
                 __lowerCamelCase		:      List[Any]											=					line[1]
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training input {text_a} is not a string'	)
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training input {text_b} is not a string'	)
                 if not isinstance(__A			,				__A	):
                     raise ValueError(f'Training label {label} is not a string'	)
                 examples.append(InputExample(guid=__A			,				text_a=__A			,				text_b=__A			,				label=__A	)	)
             return examples
  
  
  
  
  
  
  
         def 		__SCREAMING_SNAKE_CASE(   self	)     ->str:
  
  
  
             """simple docstring"""
  
  
  
  
  
  
  
             return ["contradiction", "entailment", "neutral"]
  
  __lowercase  :      Tuple      		=				{
      """xnli""": XnliProcessor,
  }
  
  __lowercase  :      Tuple      		=				{
      """xnli""": """classification""",
  }
  
  __lowercase  :      Any      		=				{
      """xnli""": 3,
  }
  
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  
  
  
  import itertools
  import random
  import unittest
  
  import numpy as np
  
  from transformers import EncodecFeatureExtractor
  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
  
  
  __lowercase  :      Any      		=				random.Random()
  
  
  
  
  
  def 							a_       (						lowercase							,						lowercase=1.0							,						lowercase=None							,						lowercase=None    )			->int:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				if rng is None:
  								__lowerCamelCase		:      Any											=					global_rng
  
  				__lowerCamelCase		:      List[Any]											=					[]
  				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 _snake_case   ( unittest.TestCase   ):
  							"""simple docstring"""
  
  
  
  
  
  							def __init__(   self			,				__A			,				__A=7			,				__A=400			,				__A=2000			,				__A=1			,				__A=0.0			,				__A=24000			,				__A=True			,				)     ->Optional[int]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Dict											=					parent
  											__lowerCamelCase		:      Tuple											=					batch_size
  											__lowerCamelCase		:      str											=					min_seq_length
  											__lowerCamelCase		:      Optional[Any]											=					max_seq_length
  											__lowerCamelCase		:      int											=					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
  											__lowerCamelCase		:      List[Any]											=					feature_size
  											__lowerCamelCase		:      int											=					padding_value
  											__lowerCamelCase		:      Optional[Any]											=					sampling_rate
  											__lowerCamelCase		:      List[str]											=					return_attention_mask
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->Optional[Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return {
  											    "feature_size": self.feature_size,
  											    "padding_value": self.padding_value,
  											    "sampling_rate": self.sampling_rate,
  											    "return_attention_mask": self.return_attention_mask,
  											}
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A=False			,				__A=False	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											def _flatten(__A	):
  															return list(itertools.chain(*__A	)	)
  
  											if equal_length:
  															__lowerCamelCase		:      Optional[int]											=					floats_list((self.batch_size, self.max_seq_length)	)
  											else:
  															# make sure that inputs increase in size
  															__lowerCamelCase		:      Optional[Any]											=					[
  															    _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		:      int											=					[np.asarray(__A	) for x in audio_inputs]
  
  											return audio_inputs
  
  
  
  
  
  @require_torch
  class _snake_case   ( a__    ,   unittest.TestCase   ):
  							"""simple docstring"""
  
  
  
  
  
  							__a												=     EncodecFeatureExtractor
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      str											=					EnCodecFeatureExtractionTester(self	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Optional[int]											=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
  											# create three inputs of length 800, 1000, and 1200
  											__lowerCamelCase		:      Optional[Any]											=					[floats_list((1, x)	)[0] for x in range(800			,				1400			,				200	)]
  											__lowerCamelCase		:      Optional[Any]											=					[np.asarray(__A	) for audio_input in audio_inputs]
  
  											# Test not batched input
  											__lowerCamelCase		:      List[str]											=					feat_extract(audio_inputs[0]			,				return_tensors="np"	).input_values
  											__lowerCamelCase		:      Union[str, Any]											=					feat_extract(np_audio_inputs[0]			,				return_tensors="np"	).input_values
  											self.assertTrue(np.allclose(__A			,				__A			,				atol=1E-3	)	)
  
  											# Test batched
  											__lowerCamelCase		:      Optional[int]											=					feat_extract(__A			,				padding=__A			,				return_tensors="np"	).input_values
  											__lowerCamelCase		:      List[str]											=					feat_extract(__A			,				padding=__A			,				return_tensors="np"	).input_values
  											for enc_seq_a, enc_seq_a in zip(__A			,				__A	):
  															self.assertTrue(np.allclose(__A			,				__A			,				atol=1E-3	)	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->List[str]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Optional[Any]											=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
  											__lowerCamelCase		:      Tuple											=					np.random.rand(100	).astype(np.floataa	)
  											__lowerCamelCase		:      Any											=					np_audio_inputs.tolist()
  
  											for inputs in [py_audio_inputs, np_audio_inputs]:
  															__lowerCamelCase		:      int											=					feature_extractor.pad([{"input_values": inputs}]			,				return_tensors="np"	)
  															self.assertTrue(np_processed.input_values.dtype == np.floataa	)
  															__lowerCamelCase		:      List[Any]											=					feature_extractor.pad([{"input_values": inputs}]			,				return_tensors="pt"	)
  															self.assertTrue(pt_processed.input_values.dtype == torch.floataa	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self			,				__A	)     ->int:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											from datasets import load_dataset
  
  											__lowerCamelCase		:      List[Any]											=					load_dataset("hf-internal-testing/librispeech_asr_dummy"			,				"clean"			,				split="validation"	)
  											# automatic decoding with librispeech
  											__lowerCamelCase		:      str											=					ds.sort("id"	).select(range(__A	)	)[:num_samples]["audio"]
  
  											return [x["array"] for x in audio_samples]
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->Tuple:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Dict											=					torch.tensor(
  											    [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
  											     3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
  											     2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
  											     4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
  											     7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
  											     4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]	)
  											# fmt: on
  											__lowerCamelCase		:      Union[str, Any]											=					self._load_datasamples(1	)
  											__lowerCamelCase		:      str											=					EncodecFeatureExtractor()
  											__lowerCamelCase		:      Optional[int]											=					feature_extractor(__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(input_values.shape			,				(1, 1, 93680)	)
  											self.assertTrue(torch.allclose(input_values[0, 0, :30]			,				__A			,				atol=1E-6	)	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->Tuple:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      Optional[Any]											=					torch.tensor(
  											    [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
  											     3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
  											     2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
  											     4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
  											     7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
  											     4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]	)
  											# fmt: on
  											__lowerCamelCase		:      Union[str, Any]											=					self._load_datasamples(1	)
  											__lowerCamelCase		:      str											=					[np.tile(input_audio[0][None]			,				reps=(2, 1)	)]
  											input_audio[0][1] *= 0.5
  											__lowerCamelCase		:      Optional[int]											=					EncodecFeatureExtractor(feature_size=2	)
  											__lowerCamelCase		:      str											=					feature_extractor(__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(input_values.shape			,				(1, 2, 93680)	)
  											self.assertTrue(torch.allclose(input_values[0, 0, :30]			,				__A			,				atol=1E-6	)	)
  											self.assertTrue(torch.allclose(input_values[0, 1, :30]			,				EXPECTED_INPUT_VALUES * 0.5			,				atol=1E-6	)	)
  
  
  
  
  
  
  
  							def 		__SCREAMING_SNAKE_CASE(   self	)     ->Optional[Any]:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											__lowerCamelCase		:      str											=					self._load_datasamples(2	)
  											# would be easier if the stride was like
  											__lowerCamelCase		:      List[Any]											=					EncodecFeatureExtractor(feature_size=1			,				chunk_length_s=1			,				overlap=0.01	)
  
  											# pad and trunc raise an error ?
  											with self.assertRaisesRegex(
  											    __A			,				"^Both padding and truncation were set. Make sure you only set one.$"			,				):
  															__lowerCamelCase		:      Dict											=					feature_extractor(
  															    __A			,				padding="max_length"			,				truncation=__A			,				return_tensors="pt"	).input_values
  
  											# truncate to chunk
  											__lowerCamelCase		:      Optional[Any]											=					feature_extractor(__A			,				truncation=__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(2, 1, 71520)	)  # 2 chunks
  
  											# force truncate to max_length
  											__lowerCamelCase		:      List[str]											=					feature_extractor(
  											    __A			,				truncation=__A			,				max_length=48000			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(2, 1, 48000)	)
  
  											# pad to chunk
  											__lowerCamelCase		:      List[str]											=					feature_extractor(__A			,				padding=__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(padded_outputs.shape			,				(2, 1, 95280)	)
  
  											# pad to chunk
  											__lowerCamelCase		:      Optional[Any]											=					feature_extractor(__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(2, 1, 95280)	)
  
  											# force pad to max length
  											__lowerCamelCase		:      int											=					feature_extractor(
  											    __A			,				padding="max_length"			,				max_length=100000			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(2, 1, 100000)	)
  
  											# force no pad
  											with self.assertRaisesRegex(
  											    __A			,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"			,				):
  															__lowerCamelCase		:      Optional[Any]											=					feature_extractor(__A			,				padding=__A			,				return_tensors="pt"	).input_values
  
  											__lowerCamelCase		:      int											=					feature_extractor(input_audio[0]			,				padding=__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(1, 1, 93680)	)
  
  											# no pad if no chunk_length_s
  											__lowerCamelCase		:      Any											=					None
  											with self.assertRaisesRegex(
  											    __A			,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"			,				):
  															__lowerCamelCase		:      int											=					feature_extractor(__A			,				padding=__A			,				return_tensors="pt"	).input_values
  
  											__lowerCamelCase		:      Any											=					feature_extractor(input_audio[0]			,				padding=__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(1, 1, 93680)	)
  
  											# no pad if no overlap
  											__lowerCamelCase		:      List[Any]											=					2
  											__lowerCamelCase		:      Any											=					None
  											with self.assertRaisesRegex(
  											    __A			,				"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"			,				):
  															__lowerCamelCase		:      Optional[int]											=					feature_extractor(__A			,				padding=__A			,				return_tensors="pt"	).input_values
  
  											__lowerCamelCase		:      List[str]											=					feature_extractor(input_audio[0]			,				padding=__A			,				return_tensors="pt"	).input_values
  											self.assertEquals(truncated_outputs.shape			,				(1, 1, 93680)	)
  
  
  
  
  
  