
'''simple docstring'''



import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
				    RwkvForCausalLM,
				    RwkvModel,
				)
				from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
				__A       =      False





class      A							:



			def __init__(   self    ,       lowerCamelCase__    ,       lowerCamelCase__=14    ,       lowerCamelCase__=7    ,       lowerCamelCase__=True    ,       lowerCamelCase__=False    ,       lowerCamelCase__=True    ,       lowerCamelCase__=True    ,       lowerCamelCase__=True    ,       lowerCamelCase__=99    ,       lowerCamelCase__=32    ,       lowerCamelCase__=5    ,       lowerCamelCase__=37    ,       lowerCamelCase__="gelu"    ,       lowerCamelCase__=0.1    ,       lowerCamelCase__=0.1    ,       lowerCamelCase__=512    ,       lowerCamelCase__=16    ,       lowerCamelCase__=2    ,       lowerCamelCase__=3    ,       lowerCamelCase__=4    ,       lowerCamelCase__=None    ,       )     ->						Union[str, Any]:




									'''simple docstring'''



									lowercase__								=    parent
									lowercase__								=    batch_size
									lowercase__								=    seq_length
									lowercase__								=    is_training
									lowercase__								=    use_token_type_ids
									lowercase__								=    use_input_mask
									lowercase__								=    use_labels
									lowercase__								=    use_mc_token_ids
									lowercase__								=    vocab_size
									lowercase__								=    hidden_size
									lowercase__								=    num_hidden_layers
									lowercase__								=    intermediate_size
									lowercase__								=    hidden_act
									lowercase__								=    hidden_dropout_prob
									lowercase__								=    attention_probs_dropout_prob
									lowercase__								=    max_position_embeddings
									lowercase__								=    type_vocab_size
									lowercase__								=    type_sequence_label_size
									lowercase__								=    num_labels
									lowercase__								=    num_choices
									lowercase__								=    scope
									lowercase__								=    vocab_size - 1
									lowercase__								=    vocab_size - 1
									lowercase__								=    vocab_size - 1



			def A__	(   self    )     ->						str:




									'''simple docstring'''



									return RwkvConfig.from_pretrained("""sgugger/rwkv-4-pile-7b"""    )



			def A__	(   self    ,       lowerCamelCase__=False    ,       lowerCamelCase__=False    ,       lowerCamelCase__=False    )     ->						str:




									'''simple docstring'''



									lowercase__								=    ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size    )

									lowercase__								=    None
									if self.use_input_mask:
															lowercase__								=    random_attention_mask([self.batch_size, self.seq_length]    )

									lowercase__								=    None
									if self.use_token_type_ids:
															lowercase__								=    ids_tensor([self.batch_size, self.seq_length]    ,       self.type_vocab_size    )

									lowercase__								=    None
									if self.use_mc_token_ids:
															lowercase__								=    ids_tensor([self.batch_size, self.num_choices]    ,       self.seq_length    )

									lowercase__								=    None
									lowercase__								=    None
									lowercase__								=    None
									if self.use_labels:
															lowercase__								=    ids_tensor([self.batch_size]    ,       self.type_sequence_label_size    )
															lowercase__								=    ids_tensor([self.batch_size, self.seq_length]    ,       self.num_labels    )
															lowercase__								=    ids_tensor([self.batch_size]    ,       self.num_choices    )

									lowercase__								=    self.get_config(
									    gradient_checkpointing=lowerCamelCase__    ,       scale_attn_by_inverse_layer_idx=lowerCamelCase__    ,       reorder_and_upcast_attn=lowerCamelCase__    ,       )

									return (
									    config,
									    input_ids,
									    input_mask,
									    None,
									    token_type_ids,
									    mc_token_ids,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									)



			def A__	(   self    ,       lowerCamelCase__=False    ,       lowerCamelCase__=False    ,       lowerCamelCase__=False    )     ->						Dict:




									'''simple docstring'''



									return RwkvConfig(
									    vocab_size=self.vocab_size    ,       hidden_size=self.hidden_size    ,       num_hidden_layers=self.num_hidden_layers    ,       intermediate_size=self.intermediate_size    ,       activation_function=self.hidden_act    ,       resid_pdrop=self.hidden_dropout_prob    ,       attn_pdrop=self.attention_probs_dropout_prob    ,       n_positions=self.max_position_embeddings    ,       type_vocab_size=self.type_vocab_size    ,       use_cache=lowerCamelCase__    ,       bos_token_id=self.bos_token_id    ,       eos_token_id=self.eos_token_id    ,       pad_token_id=self.pad_token_id    ,       gradient_checkpointing=lowerCamelCase__    ,       scale_attn_by_inverse_layer_idx=lowerCamelCase__    ,       reorder_and_upcast_attn=lowerCamelCase__    ,       )



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




									'''simple docstring'''



									lowercase__								=    self.get_config()
									lowercase__								=    300
									return config



			def A__	(   self    )     ->						Tuple:




									'''simple docstring'''



									(
									    (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,    
									)								=    self.prepare_config_and_inputs()

									lowercase__								=    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]    )
									lowercase__								=    ids_tensor([self.batch_size, self.seq_length]    ,       vocab_size=2    )

									return (
									    config,
									    input_ids,
									    input_mask,
									    head_mask,
									    token_type_ids,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									    encoder_hidden_states,
									    encoder_attention_mask,
									)



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       *lowerCamelCase__    )     ->						Union[str, Any]:




									'''simple docstring'''



									lowercase__								=    True
									lowercase__								=    RwkvModel(config=lowerCamelCase__    )
									model.to(lowerCamelCase__    )
									model.eval()

									lowercase__								=    model(lowerCamelCase__    )

									self.parent.assertEqual(result.last_hidden_state.shape    ,       (self.batch_size, self.seq_length, self.hidden_size)    )
									self.parent.assertEqual(len(result.hidden_states    )    ,       config.num_hidden_layers + 1    )



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       *lowerCamelCase__    )     ->						Union[str, Any]:




									'''simple docstring'''



									lowercase__								=    RwkvForCausalLM(lowerCamelCase__    )
									model.to(lowerCamelCase__    )
									model.eval()

									lowercase__								=    model(lowerCamelCase__    ,       labels=lowerCamelCase__    )
									self.parent.assertEqual(result.loss.shape    ,       ()    )
									self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.vocab_size)    )



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       *lowerCamelCase__    )     ->						str:




									'''simple docstring'''



									lowercase__								=    RwkvModel(config=lowerCamelCase__    )
									model.to(lowerCamelCase__    )
									model.eval()

									lowercase__								=    model(lowerCamelCase__    )
									lowercase__								=    outputs.last_hidden_state

									lowercase__								=    model(input_ids[:, :2]    )
									lowercase__								=    outputs.last_hidden_state

									# Using the state computed on the first inputs, we will get the same output
									lowercase__								=    model(input_ids[:, 2:]    ,       state=outputs.state    )
									lowercase__								=    outputs.last_hidden_state

									self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]    ,       dim=1    )    ,       lowerCamelCase__    ,       atol=1e-5    )    )



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       *lowerCamelCase__    ,       lowerCamelCase__=False    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    RwkvForCausalLM(lowerCamelCase__    )
									model.to(lowerCamelCase__    )
									if gradient_checkpointing:
															model.gradient_checkpointing_enable()

									lowercase__								=    model(lowerCamelCase__    ,       labels=lowerCamelCase__    )
									self.parent.assertEqual(result.loss.shape    ,       ()    )
									self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.vocab_size)    )
									result.loss.backward()



			def A__	(   self    )     ->						Any:




									'''simple docstring'''



									lowercase__								=    self.prepare_config_and_inputs()

									(
									    (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,  (
									    lowercase__  
									)	,    
									)								=    config_and_inputs

									lowercase__								=    {"""input_ids""": input_ids}

									return config, inputs_dict





@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0						,  reason="""See https://github.com/huggingface/transformers/pull/24204"""			)
@require_torch
class      A							(    __UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase						,  unittest.TestCase			):
			lowerCamelCase							:							Optional[Any]    						=					(RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
			lowerCamelCase							:							List[str]    						=					(
			    {"""feature-extraction""": RwkvModel, """text-generation""": RwkvForCausalLM} if is_torch_available() else {}
			)
			# all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
			lowerCamelCase							:							int    						=					False
			lowerCamelCase							:							List[Any]    						=					False
			lowerCamelCase							:							str    						=					False
			lowerCamelCase							:							List[str]    						=					False
			lowerCamelCase							:							Optional[int]    						=					False  # Rwkv does not support head masking



			def A__	(   self    )     ->						Tuple:




									'''simple docstring'''



									lowercase__								=    RwkvModelTester(self    )
									lowercase__								=    ConfigTester(
									    self    ,       config_class=lowerCamelCase__    ,       n_embd=37    ,       common_properties=["""hidden_size""", """num_hidden_layers"""]    )



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__=None    )     ->						Optional[Any]:




									'''simple docstring'''



									if isinstance(lowerCamelCase__    ,       torch.Tensor    ):
															lowercase__	,  lowercase__								=    member.max().item(), member.min().item()
									elif isinstance(lowerCamelCase__    ,       lowerCamelCase__    ) or isinstance(lowerCamelCase__    ,       lowerCamelCase__    ):
															lowercase__	,  lowercase__								=    max(lowerCamelCase__    ), min(lowerCamelCase__    )

									if not isinstance(lowerCamelCase__    ,       lowerCamelCase__    ):
															raise TypeError("""container should be a list or tuple"""    )
									elif len(lowerCamelCase__    ) != 2:
															raise ValueError("""container should have 2 elements"""    )

									lowercase__	,  lowercase__								=    container

									lowercase__								=    (min_value >= expected_min) and (max_value <= expected_max)

									if not is_inside_interval:
															lowercase__								=    """%s not found in %s""" % (safe_repr(lowerCamelCase__    ), safe_repr(lowerCamelCase__    ))
															self.fail(self._formatMessage(lowerCamelCase__    ,       lowerCamelCase__    )    )



			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									self.config_tester.run_common_tests()



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




									'''simple docstring'''



									lowercase__								=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_rwkv_model(*lowerCamelCase__    )



			def A__	(   self    )     ->						Any:




									'''simple docstring'''



									lowercase__								=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_causl_lm(*lowerCamelCase__    )



			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									lowercase__								=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_state_equivalency(*lowerCamelCase__    )



			def A__	(   self    )     ->						List[str]:




									'''simple docstring'''



									lowercase__	,  lowercase__								=    self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															lowercase__								=    model_class(config=lowerCamelCase__    )
															for name, param in model.named_parameters():
																					if "time_decay" in name:
																											if param.requires_grad:
																																	self.assertTrue(param.data.max().item() == 3.0    )
																																	self.assertTrue(param.data.min().item() == -5.0    )
																					elif "time_first" in name:
																											if param.requires_grad:
																																	# check if it's a ones like
																																	self.assertTrue(torch.allclose(param.data    ,       torch.ones_like(param.data    )    ,       atol=1e-5    ,       rtol=1e-5    )    )
																					elif any(x in name for x in ["""time_mix_key""", """time_mix_receptance"""]    ):
																											if param.requires_grad:
																																	self.assertInterval(
																																	    param.data    ,       [0.0, 1.0]    ,       msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''    ,       )
																					elif "time_mix_value" in name:
																											if param.requires_grad:
																																	self.assertInterval(
																																	    param.data    ,       [0.0, 1.3]    ,       msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''    ,       )



			def A__	(   self    )     ->						str:




									'''simple docstring'''



									lowercase__	,  lowercase__								=    self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__								=    True

									lowercase__								=    getattr(self.model_tester    ,       """seq_length"""    ,       lowerCamelCase__    )

									for model_class in self.all_model_classes:
															lowercase__								=    True
															lowercase__								=    False
															lowercase__								=    True
															lowercase__								=    model_class(lowerCamelCase__    )
															model.to(lowerCamelCase__    )
															model.eval()

															lowercase__								=    self._prepare_for_class(lowerCamelCase__    ,       lowerCamelCase__    )
															lowercase__								=    inputs["""input_ids"""].shape[0]
															with torch.no_grad():
																					lowercase__								=    model(**lowerCamelCase__    )
															lowercase__								=    outputs.attentions
															self.assertEqual(len(lowerCamelCase__    )    ,       self.model_tester.num_hidden_layers    )

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															lowercase__								=    True
															lowercase__								=    model_class(lowerCamelCase__    )
															model.to(lowerCamelCase__    )
															model.eval()

															lowercase__								=    self._prepare_for_class(lowerCamelCase__    ,       lowerCamelCase__    )
															lowercase__								=    inputs["""input_ids"""].shape[0]
															with torch.no_grad():
																					lowercase__								=    model(**lowerCamelCase__    )
															lowercase__								=    outputs.attentions
															self.assertEqual(len(lowerCamelCase__    )    ,       self.model_tester.num_hidden_layers    )

															self.assertListEqual(
															    list(attentions[0].shape[-3:]    )    ,       [batch_size, seq_len, config.hidden_size]    ,       )
															lowercase__								=    len(lowerCamelCase__    )

															# Check attention is always last and order is fine
															lowercase__								=    True
															lowercase__								=    True
															lowercase__								=    model_class(lowerCamelCase__    )
															model.to(lowerCamelCase__    )
															model.eval()

															lowercase__								=    self._prepare_for_class(lowerCamelCase__    ,       lowerCamelCase__    )
															lowercase__								=    inputs["""input_ids"""].shape[0]
															with torch.no_grad():
																					lowercase__								=    model(**lowerCamelCase__    )

															lowercase__								=    1
															self.assertEqual(out_len + added_hidden_states    ,       len(lowerCamelCase__    )    )

															lowercase__								=    outputs.attentions

															self.assertEqual(len(lowerCamelCase__    )    ,       self.model_tester.num_hidden_layers    )
															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]    )    ,       [batch_size, seq_len, config.hidden_size]    ,       )



			@slow
			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowercase__								=    RwkvModel.from_pretrained(lowerCamelCase__    )
															self.assertIsNotNone(lowerCamelCase__    )





@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0						,  reason="""See https://github.com/huggingface/transformers/pull/24204"""			)
@slow
class      A							(    unittest.TestCase			):



			def A__	(   self    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    """RWKV/rwkv-4-169m-pile"""
									lowercase__								=    AutoTokenizer.from_pretrained(self.model_id    )



			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									lowercase__								=    """Hello my name is Jasmine and I am a newbie to the"""
									lowercase__								=    RwkvForCausalLM.from_pretrained(self.model_id    ).to(lowerCamelCase__    )

									lowercase__								=    self.tokenizer("""Hello my name is"""    ,       return_tensors="""pt"""    ).input_ids.to(lowerCamelCase__    )
									lowercase__								=    model.generate(lowerCamelCase__    ,       max_new_tokens=10    )
									lowercase__								=    self.tokenizer.decode(output[0].tolist()    )

									self.assertEqual(lowerCamelCase__    ,       lowerCamelCase__    )



			def A__	(   self    )     ->						Optional[Any]:




									'''simple docstring'''



									lowercase__								=    """Hello my name is Jasmine and I am a newbie to the"""

									lowercase__								=    self.tokenizer("""Hello my name is"""    ,       return_tensors="""pt"""    ).input_ids.to(lowerCamelCase__    )
									lowercase__								=    RwkvForCausalLM.from_pretrained(self.model_id    ,       torch_dtype=torch.bfloataa    ).to(lowerCamelCase__    )

									lowercase__								=    model.generate(lowerCamelCase__    ,       max_new_tokens=10    )
									lowercase__								=    self.tokenizer.decode(output[0].tolist()    )

									self.assertEqual(lowerCamelCase__    ,       lowerCamelCase__    )





'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list





class      A							(    unittest.TestCase			):



			def A__	(   self    )     ->						Union[str, Any]:




									'''simple docstring'''



									lowercase__								=    """<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z""".split(""" """    )
									lowercase__								=    dict(zip(lowerCamelCase__    ,       range(len(lowerCamelCase__    )    )    )    )

									lowercase__								=    {
									    """pad_token""": """<pad>""",
									    """unk_token""": """<unk>""",
									    """bos_token""": """<s>""",
									    """eos_token""": """</s>""",
									}
									lowercase__								=    {
									    """feature_size""": 1,
									    """padding_value""": 0.0,
									    """sampling_rate""": 16_000,
									    """return_attention_mask""": False,
									    """do_normalize""": True,
									}

									lowercase__								=    tempfile.mkdtemp()
									lowercase__								=    os.path.join(self.tmpdirname    ,       VOCAB_FILES_NAMES["""vocab_file"""]    )
									lowercase__								=    os.path.join(self.tmpdirname    ,       lowerCamelCase__    )
									with open(self.vocab_file    ,       """w"""    ,       encoding="""utf-8"""    ) as fp:
															fp.write(json.dumps(lowerCamelCase__    ) + """\n"""    )

									with open(self.feature_extraction_file    ,       """w"""    ,       encoding="""utf-8"""    ) as fp:
															fp.write(json.dumps(lowerCamelCase__    ) + """\n"""    )



			def A__	(   self    ,       **lowerCamelCase__    )     ->						int:




									'''simple docstring'''



									lowercase__								=    self.add_kwargs_tokens_map.copy()
									kwargs.update(lowerCamelCase__    )
									return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname    ,       **lowerCamelCase__    )



			def A__	(   self    ,       **lowerCamelCase__    )     ->						Dict:




									'''simple docstring'''



									return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname    ,       **lowerCamelCase__    )



			def A__	(   self    )     ->						Dict:




									'''simple docstring'''



									shutil.rmtree(self.tmpdirname    )



			def A__	(   self    )     ->						str:




									'''simple docstring'''



									lowercase__								=    self.get_tokenizer()
									lowercase__								=    self.get_feature_extractor()

									lowercase__								=    WavaVecaProcessor(tokenizer=lowerCamelCase__    ,       feature_extractor=lowerCamelCase__    )

									processor.save_pretrained(self.tmpdirname    )
									lowercase__								=    WavaVecaProcessor.from_pretrained(self.tmpdirname    )

									self.assertEqual(processor.tokenizer.get_vocab()    ,       tokenizer.get_vocab()    )
									self.assertIsInstance(processor.tokenizer    ,       lowerCamelCase__    )

									self.assertEqual(processor.feature_extractor.to_json_string()    ,       feature_extractor.to_json_string()    )
									self.assertIsInstance(processor.feature_extractor    ,       lowerCamelCase__    )



			def A__	(   self    )     ->						Tuple:




									'''simple docstring'''



									lowercase__								=    WavaVecaProcessor(tokenizer=self.get_tokenizer()    ,       feature_extractor=self.get_feature_extractor()    )
									processor.save_pretrained(self.tmpdirname    )

									lowercase__								=    self.get_tokenizer(bos_token="""(BOS)"""    ,       eos_token="""(EOS)"""    )
									lowercase__								=    self.get_feature_extractor(do_normalize=lowerCamelCase__    ,       padding_value=1.0    )

									lowercase__								=    WavaVecaProcessor.from_pretrained(
									    self.tmpdirname    ,       bos_token="""(BOS)"""    ,       eos_token="""(EOS)"""    ,       do_normalize=lowerCamelCase__    ,       padding_value=1.0    )

									self.assertEqual(processor.tokenizer.get_vocab()    ,       tokenizer_add_kwargs.get_vocab()    )
									self.assertIsInstance(processor.tokenizer    ,       lowerCamelCase__    )

									self.assertEqual(processor.feature_extractor.to_json_string()    ,       feature_extractor_add_kwargs.to_json_string()    )
									self.assertIsInstance(processor.feature_extractor    ,       lowerCamelCase__    )



			def A__	(   self    )     ->						List[str]:




									'''simple docstring'''



									lowercase__								=    self.get_feature_extractor()
									lowercase__								=    self.get_tokenizer()

									lowercase__								=    WavaVecaProcessor(tokenizer=lowerCamelCase__    ,       feature_extractor=lowerCamelCase__    )

									lowercase__								=    floats_list((3, 1_000)    )

									lowercase__								=    feature_extractor(lowerCamelCase__    ,       return_tensors="""np"""    )
									lowercase__								=    processor(lowerCamelCase__    ,       return_tensors="""np"""    )

									for key in input_feat_extract.keys():
															self.assertAlmostEqual(input_feat_extract[key].sum()    ,       input_processor[key].sum()    ,       delta=1e-2    )



			def A__	(   self    )     ->						Optional[Any]:




									'''simple docstring'''



									lowercase__								=    self.get_feature_extractor()
									lowercase__								=    self.get_tokenizer()

									lowercase__								=    WavaVecaProcessor(tokenizer=lowerCamelCase__    ,       feature_extractor=lowerCamelCase__    )

									lowercase__								=    """This is a test string"""

									lowercase__								=    processor(text=lowerCamelCase__    )

									lowercase__								=    tokenizer(lowerCamelCase__    )

									for key in encoded_tok.keys():
															self.assertListEqual(encoded_tok[key]    ,       encoded_processor[key]    )



			def A__	(   self    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    self.get_feature_extractor()
									lowercase__								=    self.get_tokenizer()

									lowercase__								=    WavaVecaProcessor(tokenizer=lowerCamelCase__    ,       feature_extractor=lowerCamelCase__    )

									lowercase__								=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									lowercase__								=    processor.batch_decode(lowerCamelCase__    )
									lowercase__								=    tokenizer.batch_decode(lowerCamelCase__    )

									self.assertListEqual(lowerCamelCase__    ,       lowerCamelCase__    )



			def A__	(   self    )     ->						List[str]:




									'''simple docstring'''



									lowercase__								=    self.get_feature_extractor()
									lowercase__								=    self.get_tokenizer()

									lowercase__								=    WavaVecaProcessor(tokenizer=lowerCamelCase__    ,       feature_extractor=lowerCamelCase__    )

									self.assertListEqual(
									    processor.model_input_names    ,       feature_extractor.model_input_names    ,       msg="""`processor` and `feature_extractor` model input names do not match"""    ,       )






