
import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


lowercase__				:				str						=      logging.getLogger(__name__)

require_version("pytorch_lightning>=1.0.4")

lowercase__				:				Tuple						=      {
    """base""": AutoModel,
    """sequence-classification""": AutoModelForSequenceClassification,
    """question-answering""": AutoModelForQuestionAnswering,
    """pretraining""": AutoModelForPreTraining,
    """token-classification""": AutoModelForTokenClassification,
    """language-modeling""": AutoModelWithLMHead,
    """summarization""": AutoModelForSeqaSeqLM,
    """translation""": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
lowercase__				:				Dict						=      {
    """linear""": get_linear_schedule_with_warmup,
    """cosine""": get_cosine_schedule_with_warmup,
    """cosine_w_restarts""": get_cosine_with_hard_restarts_schedule_with_warmup,
    """polynomial""": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
lowercase__				:				Optional[Any]						=      sorted(arg_to_scheduler.keys())
lowercase__				:				str						=      """{""" + """, """.join(arg_to_scheduler_choices) + """}"""






class 							SCREAMING_SNAKE_CASE__     (				pl.LightningModule     ):

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_="base"  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_=None  ,						**SCREAMING_SNAKE_CASE_  ,						)-> str:





													'''simple docstring'''






													super().__init__()
													# TODO: move to self.save_hyperparameters()
													# self.save_hyperparameters()
													# can also expand arguments into trainer signature for easier reading

													self.save_hyperparameters(lowerCAmelCase__      )
													__UpperCamelCase  	=      0
													__UpperCamelCase  	=      Path(self.hparams.output_dir      )
													__UpperCamelCase  	=      self.hparams.cache_dir if self.hparams.cache_dir else None
													if config is None:
																			__UpperCamelCase  	=      AutoConfig.from_pretrained(
																			    self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path  ,						**({'''num_labels''': num_labels} if num_labels is not None else {})  ,						cache_dir=lowerCAmelCase__  ,						**lowerCAmelCase__  ,						)
													else:
																			__UpperCamelCase  	=      config

													__UpperCamelCase  	=      ("""encoder_layerdrop""", """decoder_layerdrop""", """dropout""", """attention_dropout""")
													for p in extra_model_params:
																			if getattr(self.hparams  ,						lowerCAmelCase__  ,						lowerCAmelCase__      ):
																									assert hasattr(self.config  ,						lowerCAmelCase__      ), F"model config doesn\'t have a `{p}` attribute"
																									setattr(self.config  ,						lowerCAmelCase__  ,						getattr(self.hparams  ,						lowerCAmelCase__      )      )

													if tokenizer is None:
																			__UpperCamelCase  	=      AutoTokenizer.from_pretrained(
																			    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path  ,						cache_dir=lowerCAmelCase__  ,						)
													else:
																			__UpperCamelCase  	=      tokenizer
													__UpperCamelCase  	=      MODEL_MODES[mode]
													if model is None:
																			__UpperCamelCase  	=      self.model_type.from_pretrained(
																			    self.hparams.model_name_or_path  ,						from_tf=bool('''.ckpt''' in self.hparams.model_name_or_path      )  ,						config=self.config  ,						cache_dir=lowerCAmelCase__  ,						)
													else:
																			__UpperCamelCase  	=      model



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





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_type.from_pretrained(*lowerCAmelCase__  ,						**lowerCAmelCase__      )



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





													'''simple docstring'''






													__UpperCamelCase  	=      arg_to_scheduler[self.hparams.lr_scheduler]
													__UpperCamelCase  	=      get_schedule_func(
													    self.opt  ,						num_warmup_steps=self.hparams.warmup_steps  ,						num_training_steps=self.total_steps()      )
													__UpperCamelCase  	=      {"""scheduler""": scheduler, """interval""": """step""", """frequency""": 1}
													return scheduler



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





													'''simple docstring'''






													__UpperCamelCase  	=      self.model
													__UpperCamelCase  	=      ["""bias""", """LayerNorm.weight"""]
													__UpperCamelCase  	=      [
													    {
													        """params""": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay      )],
													        """weight_decay""": self.hparams.weight_decay,
													    },
													    {
													        """params""": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay      )],
													        """weight_decay""": 0.0,
													    },
													]
													if self.hparams.adafactor:
																			__UpperCamelCase  	=      Adafactor(
																			    lowerCAmelCase__  ,						lr=self.hparams.learning_rate  ,						scale_parameter=lowerCAmelCase__  ,						relative_step=lowerCAmelCase__      )

													else:
																			__UpperCamelCase  	=      AdamW(
																			    lowerCAmelCase__  ,						lr=self.hparams.learning_rate  ,						eps=self.hparams.adam_epsilon      )
													__UpperCamelCase  	=      optimizer

													__UpperCamelCase  	=      self.get_lr_scheduler()

													return [optimizer], [scheduler]



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Tuple:





													'''simple docstring'''






													return self.validation_step(lowerCAmelCase__  ,						lowerCAmelCase__      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_      )-> Tuple:





													'''simple docstring'''






													return self.validation_end(lowerCAmelCase__      )



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase  	=      max(1  ,						self.hparams.gpus      )  # TODO: consider num_tpu_cores
													__UpperCamelCase  	=      self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
													return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs



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





													'''simple docstring'''






													if mode == "test":
																			__UpperCamelCase  	=      len(self.test_dataloader().dataset      )
													else:
																			__UpperCamelCase  	=      self.get_dataloader('''train'''  ,						self.hparams.train_batch_size  ,						shuffle=lowerCAmelCase__      )
																			__UpperCamelCase  	=      len(self.train_dataloader().dataset      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_ = False      )-> List[str]:





													'''simple docstring'''






													raise NotImplementedError('''You must implement this for your task'''      )



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





													'''simple docstring'''






													return self.train_loader



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





													'''simple docstring'''






													return self.get_dataloader('''dev'''  ,						self.hparams.eval_batch_size  ,						shuffle=lowerCAmelCase__      )



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





													'''simple docstring'''






													return self.get_dataloader('''test'''  ,						self.hparams.eval_batch_size  ,						shuffle=lowerCAmelCase__      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_      )-> int:





													'''simple docstring'''






													return os.path.join(
													    self.hparams.data_dir  ,						'''cached_{}_{}_{}'''.format(
													        lowerCAmelCase__  ,						list(filter(lowerCAmelCase__  ,						self.hparams.model_name_or_path.split('''/'''      )      )      ).pop()  ,						str(self.hparams.max_seq_length      )  ,						)  ,						)



							@pl.utilities.rank_zero_only
							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_      )-> None:





													'''simple docstring'''






													__UpperCamelCase  	=      self.output_dir.joinpath('''best_tfmr'''      )
													__UpperCamelCase  	=      self.step_count
													self.model.save_pretrained(lowerCAmelCase__      )
													self.tokenizer.save_pretrained(lowerCAmelCase__      )



							@staticmethod
							def      A__		(	SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> str:





													'''simple docstring'''






													parser.add_argument(
													    '''--model_name_or_path'''  ,						default=lowerCAmelCase__  ,						type=lowerCAmelCase__  ,						required=lowerCAmelCase__  ,						help='''Path to pretrained model or model identifier from huggingface.co/models'''  ,						)
													parser.add_argument(
													    '''--config_name'''  ,						default=''''''  ,						type=lowerCAmelCase__  ,						help='''Pretrained config name or path if not the same as model_name'''      )
													parser.add_argument(
													    '''--tokenizer_name'''  ,						default=lowerCAmelCase__  ,						type=lowerCAmelCase__  ,						help='''Pretrained tokenizer name or path if not the same as model_name'''  ,						)
													parser.add_argument(
													    '''--cache_dir'''  ,						default=''''''  ,						type=lowerCAmelCase__  ,						help='''Where do you want to store the pre-trained models downloaded from huggingface.co'''  ,						)
													parser.add_argument(
													    '''--encoder_layerdrop'''  ,						type=lowerCAmelCase__  ,						help='''Encoder layer dropout probability (Optional). Goes into model.config'''  ,						)
													parser.add_argument(
													    '''--decoder_layerdrop'''  ,						type=lowerCAmelCase__  ,						help='''Decoder layer dropout probability (Optional). Goes into model.config'''  ,						)
													parser.add_argument(
													    '''--dropout'''  ,						type=lowerCAmelCase__  ,						help='''Dropout probability (Optional). Goes into model.config'''  ,						)
													parser.add_argument(
													    '''--attention_dropout'''  ,						type=lowerCAmelCase__  ,						help='''Attention dropout probability (Optional). Goes into model.config'''  ,						)
													parser.add_argument('''--learning_rate'''  ,						default=5E-5  ,						type=lowerCAmelCase__  ,						help='''The initial learning rate for Adam.'''      )
													parser.add_argument(
													    '''--lr_scheduler'''  ,						default='''linear'''  ,						choices=lowerCAmelCase__  ,						metavar=lowerCAmelCase__  ,						type=lowerCAmelCase__  ,						help='''Learning rate scheduler'''  ,						)
													parser.add_argument('''--weight_decay'''  ,						default=0.0  ,						type=lowerCAmelCase__  ,						help='''Weight decay if we apply some.'''      )
													parser.add_argument('''--adam_epsilon'''  ,						default=1E-8  ,						type=lowerCAmelCase__  ,						help='''Epsilon for Adam optimizer.'''      )
													parser.add_argument('''--warmup_steps'''  ,						default=0  ,						type=lowerCAmelCase__  ,						help='''Linear warmup over warmup_steps.'''      )
													parser.add_argument('''--num_workers'''  ,						default=4  ,						type=lowerCAmelCase__  ,						help='''kwarg passed to DataLoader'''      )
													parser.add_argument('''--num_train_epochs'''  ,						dest='''max_epochs'''  ,						default=3  ,						type=lowerCAmelCase__      )
													parser.add_argument('''--train_batch_size'''  ,						default=32  ,						type=lowerCAmelCase__      )
													parser.add_argument('''--eval_batch_size'''  ,						default=32  ,						type=lowerCAmelCase__      )
													parser.add_argument('''--adafactor'''  ,						action='''store_true'''      )






class 							SCREAMING_SNAKE_CASE__     (				pl.Callback     ):

							"""simple docstring"""






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





													'''simple docstring'''






													__UpperCamelCase  	=      trainer.lr_schedulers[0]["""scheduler"""]
													__UpperCamelCase  	=      {F"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr()      )}
													pl_module.logger.log_metrics(lowerCAmelCase__      )



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





													'''simple docstring'''






													rank_zero_info('''***** Validation results *****'''      )
													__UpperCamelCase  	=      trainer.callback_metrics
													# Log results
													for key in sorted(lowerCAmelCase__      ):
																			if key not in ["log", "progress_bar"]:
																									rank_zero_info('''{} = {}\n'''.format(lowerCAmelCase__  ,						str(metrics[key]      )      )      )



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Tuple:





													'''simple docstring'''






													rank_zero_info('''***** Test results *****'''      )
													__UpperCamelCase  	=      trainer.callback_metrics
													# Log and save results to file
													__UpperCamelCase  	=      os.path.join(pl_module.hparams.output_dir  ,						'''test_results.txt'''      )
													with open(lowerCAmelCase__  ,						'''w'''      ) as writer:
																			for key in sorted(lowerCAmelCase__      ):
																									if key not in ["log", "progress_bar"]:
																															rank_zero_info('''{} = {}\n'''.format(lowerCAmelCase__  ,						str(metrics[key]      )      )      )
																															writer.write('''{} = {}\n'''.format(lowerCAmelCase__  ,						str(metrics[key]      )      )      )





def 						A_			(				snake_case				: Optional[int]			,   snake_case				: Dict			)   ->     None:



						'''simple docstring'''

						parser.add_argument(
						    '''--output_dir'''			,   default=__a			,   type=__a			,   required=__a			,   help='''The output directory where the model predictions and checkpoints will be written.'''			,   )
						parser.add_argument(
						    '''--fp16'''			,   action='''store_true'''			,   help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit'''			,   )

						parser.add_argument(
						    '''--fp16_opt_level'''			,   type=__a			,   default='''O2'''			,   help=(
						        '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].'''
						        '''See details at https://nvidia.github.io/apex/amp.html'''
						    )			,   )
						parser.add_argument('''--n_tpu_cores'''			,   dest='''tpu_cores'''			,   type=__a			)
						parser.add_argument('''--max_grad_norm'''			,   dest='''gradient_clip_val'''			,   default=1.0			,   type=__a			,   help='''Max gradient norm'''			)
						parser.add_argument('''--do_train'''			,   action='''store_true'''			,   help='''Whether to run training.'''			)
						parser.add_argument('''--do_predict'''			,   action='''store_true'''			,   help='''Whether to run predictions on the test set.'''			)
						parser.add_argument(
						    '''--gradient_accumulation_steps'''			,   dest='''accumulate_grad_batches'''			,   type=__a			,   default=1			,   help='''Number of updates steps to accumulate before performing a backward/update pass.'''			,   )
						parser.add_argument('''--seed'''			,   type=__a			,   default=42			,   help='''random seed for initialization'''			)
						parser.add_argument(
						    '''--data_dir'''			,   default=__a			,   type=__a			,   required=__a			,   help='''The input data dir. Should contain the training files for the CoNLL-2003 NER task.'''			,   )




def 						A_			(				snake_case				: Union[str, Any]			,   snake_case				: Any			,   snake_case				: str=None			,   snake_case				: Tuple=True			,   snake_case				: Optional[int]=[]			,   snake_case				: Tuple=None			,   snake_case				: Union[str, Any]=None			,   **snake_case				: Union[str, Any]			,   )   ->     str:



						'''simple docstring'''

						pl.seed_everything(args.seed			)

						# init model
						__UpperCamelCase  	=      Path(model.hparams.output_dir			)
						odir.mkdir(exist_ok=__a			)

						# add custom checkpoints
						if checkpoint_callback is None:
												__UpperCamelCase  	=      pl.callbacks.ModelCheckpoint(
												    filepath=args.output_dir			,   prefix='''checkpoint'''			,   monitor='''val_loss'''			,   mode='''min'''			,   save_top_k=1			)
						if early_stopping_callback:
												extra_callbacks.append(__a			)
						if logging_callback is None:
												__UpperCamelCase  	=      LoggingCallback()

						__UpperCamelCase  	=      {}

						# TODO: remove with PyTorch 1.6 since pl uses native amp
						if args.fpaa:
												__UpperCamelCase  	=      16
												__UpperCamelCase  	=      args.fpaa_opt_level

						if args.gpus > 1:
												__UpperCamelCase  	=      """ddp"""

						__UpperCamelCase  	=      args.accumulate_grad_batches
						__UpperCamelCase  	=      extra_train_kwargs.get('''accelerator'''			,   __a			)
						__UpperCamelCase  	=      extra_train_kwargs.get('''profiler'''			,   __a			)

						__UpperCamelCase  	=      pl.Trainer.from_argparse_args(
						    __a			,   weights_summary=__a			,   callbacks=[logging_callback] + extra_callbacks			,   logger=__a			,   checkpoint_callback=__a			,   **__a			,   )

						if args.do_train:
												trainer.fit(__a			)

						return trainer





'''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    lowerCamelCase__  (   unittest.TestCase     ):



   def  _UpperCamelCase		(    self     )				->     str:
        """simple docstring"""





        _UpperCamelCase  :Any       ="""<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(""" """     )
        _UpperCamelCase  :Optional[Any]       =dict(zip(lowerCAmelCase__					,      range(len(lowerCAmelCase__     )     )     )     )

        _UpperCamelCase  :int       ={
            """pad_token""": """<pad>""",
            """unk_token""": """<unk>""",
            """bos_token""": """<s>""",
            """eos_token""": """</s>""",
        }
        _UpperCamelCase  :Union[str, Any]       ={
            """feature_size""": 1,
            """padding_value""": 0.0,
            """sampling_rate""": 16_000,
            """return_attention_mask""": False,
            """do_normalize""": True,
        }

        _UpperCamelCase  :List[str]       =tempfile.mkdtemp()
        _UpperCamelCase  :Optional[Any]       =os.path.join(self.tmpdirname					,      VOCAB_FILES_NAMES["""vocab_file"""]     )
        _UpperCamelCase  :Tuple       =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  _UpperCamelCase		(    self					,      **lowerCAmelCase__     )				->     List[str]:
        """simple docstring"""





        _UpperCamelCase  :int       =self.add_kwargs_tokens_map.copy()
        kwargs.update(lowerCAmelCase__     )
        return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname					,      **lowerCAmelCase__     )



   def  _UpperCamelCase		(    self					,      **lowerCAmelCase__     )				->     str:
        """simple docstring"""





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



   def  _UpperCamelCase		(    self     )				->     List[str]:
        """simple docstring"""





        shutil.rmtree(self.tmpdirname     )



   def  _UpperCamelCase		(    self     )				->     int:
        """simple docstring"""





        _UpperCamelCase  :Union[str, Any]       =self.get_tokenizer()
        _UpperCamelCase  :int       =self.get_feature_extractor()

        _UpperCamelCase  :Union[str, Any]       =WavaVecaProcessor(tokenizer=lowerCAmelCase__					,      feature_extractor=lowerCAmelCase__     )

        processor.save_pretrained(self.tmpdirname     )
        _UpperCamelCase  :Dict       =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  _UpperCamelCase		(    self     )				->     Tuple:
        """simple docstring"""





        _UpperCamelCase  :Union[str, Any]       =WavaVecaProcessor(tokenizer=self.get_tokenizer()					,      feature_extractor=self.get_feature_extractor()     )
        processor.save_pretrained(self.tmpdirname     )

        _UpperCamelCase  :Optional[int]       =self.get_tokenizer(bos_token="""(BOS)"""					,      eos_token="""(EOS)"""     )
        _UpperCamelCase  :Optional[int]       =self.get_feature_extractor(do_normalize=lowerCAmelCase__					,      padding_value=1.0     )

        _UpperCamelCase  :Optional[int]       =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  _UpperCamelCase		(    self     )				->     int:
        """simple docstring"""





        _UpperCamelCase  :List[Any]       =self.get_feature_extractor()
        _UpperCamelCase  :List[str]       =self.get_tokenizer()

        _UpperCamelCase  :Any       =WavaVecaProcessor(tokenizer=lowerCAmelCase__					,      feature_extractor=lowerCAmelCase__     )

        _UpperCamelCase  :Tuple       =floats_list((3, 1_000)     )

        _UpperCamelCase  :Tuple       =feature_extractor(lowerCAmelCase__					,      return_tensors="""np"""     )
        _UpperCamelCase  :Union[str, Any]       =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  _UpperCamelCase		(    self     )				->     Tuple:
        """simple docstring"""





        _UpperCamelCase  :Any       =self.get_feature_extractor()
        _UpperCamelCase  :List[Any]       =self.get_tokenizer()

        _UpperCamelCase  :Tuple       =WavaVecaProcessor(tokenizer=lowerCAmelCase__					,      feature_extractor=lowerCAmelCase__     )

        _UpperCamelCase  :Optional[Any]       ="""This is a test string"""

        _UpperCamelCase  :Union[str, Any]       =processor(text=lowerCAmelCase__     )

        _UpperCamelCase  :Union[str, Any]       =tokenizer(lowerCAmelCase__     )

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



   def  _UpperCamelCase		(    self     )				->     Optional[Any]:
        """simple docstring"""





        _UpperCamelCase  :int       =self.get_feature_extractor()
        _UpperCamelCase  :Any       =self.get_tokenizer()

        _UpperCamelCase  :str       =WavaVecaProcessor(tokenizer=lowerCAmelCase__					,      feature_extractor=lowerCAmelCase__     )

        _UpperCamelCase  :Optional[int]       =[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        _UpperCamelCase  :List[Any]       =processor.batch_decode(lowerCAmelCase__     )
        _UpperCamelCase  :Any       =tokenizer.batch_decode(lowerCAmelCase__     )

        self.assertListEqual(lowerCAmelCase__					,      lowerCAmelCase__     )




   def  _UpperCamelCase		(    self     )				->     Union[str, Any]:
        """simple docstring"""





        _UpperCamelCase  :List[Any]       =self.get_feature_extractor()
        _UpperCamelCase  :Any       =self.get_tokenizer()

        _UpperCamelCase  :List[str]       =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"""					,      )