
'''simple docstring'''






import argparse
import os
from dataclasses import dataclass

import torch
import torchaudio
from tqdm import tqdm

from transformers import AutoConfig, AutoModelForCTC, AutoProcessor

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: Union[str, Any]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Tuple      ):
			lowerCAmelCase_   :       str    							=cuda
			lowerCAmelCase_   :       int    							=AutoConfig.from_pretrained(UpperCamelCase_      )
			lowerCAmelCase_   :       Dict    							=AutoModelForCTC.from_pretrained(UpperCamelCase_      )
			self.model.eval()
			if self.cuda:
					self.model.to(device='''cuda'''      )
			lowerCAmelCase_   :       List[Any]    							=AutoProcessor.from_pretrained(UpperCamelCase_      )
			lowerCAmelCase_   :       Dict    							=torchaudio.transforms.Resample(UpperCamelCase_					,						16000      )
			lowerCAmelCase_   :       List[str]    							=0
			lowerCAmelCase_   :       List[Any]    							=list(self.processor.tokenizer.get_vocab().keys()      )
			for i in range(len(UpperCamelCase_      )      ):
					if vocab[i] == "[PAD]" or vocab[i] == "<pad>":
							lowerCAmelCase_   :       str    							=i
			print('''Blank Token id [PAD]/<pad>'''					,						UpperCamelCase_      )
			lowerCAmelCase_   :       Tuple    							=blank_id




	def 	__A      (						self				: Dict					,						UpperCamelCase_				: Optional[int]      ):
			lowerCAmelCase_							,		lowerCAmelCase_   :       Optional[int]    							=torchaudio.load(UpperCamelCase_      )
			lowerCAmelCase_   :       List[Any]    							=self.resampler(UpperCamelCase_      ).squeeze().numpy()
			return speech




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: List[str]      ):
			lowerCAmelCase_   :       List[Any]    							=self.blank_id
			lowerCAmelCase_   :       List[Any]    							='''|'''.join(item['''sent'''].split(''' '''      )      )
			if not os.path.isfile(item['''wav_path''']      ):
					print(item['''wav_path''']					,						'''not found in wavs directory'''      )

			lowerCAmelCase_   :       Dict    							=self.speech_file_to_array_fn(item['''wav_path''']      )
			lowerCAmelCase_   :       List[str]    							=self.processor(UpperCamelCase_					,						sampling_rate=16000					,						return_tensors='''pt'''					,						padding=UpperCamelCase_      )
			if self.cuda:
					lowerCAmelCase_   :       Tuple    							=inputs.to(device='''cuda'''      )

			with torch.no_grad():
					lowerCAmelCase_   :       str    							=self.model(inputs.input_values      ).logits

			# get the emission probability at frame level
			lowerCAmelCase_   :       Any    							=torch.log_softmax(UpperCamelCase_					,						dim=-1      )
			lowerCAmelCase_   :       Union[str, Any]    							=emissions[0].cpu().detach()

			# get labels from vocab
			lowerCAmelCase_   :       List[str]    							=([''''''] + list(self.processor.tokenizer.get_vocab().keys()      ))[
			    :-1
			]  # logits don't align with the tokenizer's vocab

			lowerCAmelCase_   :       Any    							={c: i for i, c in enumerate(UpperCamelCase_      )}
			lowerCAmelCase_   :       List[Any]    							=[]
			for c in transcript:
					if c in dictionary:
							tokens.append(dictionary[c]      )

			def get_trellis(UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Dict=0      ):
					lowerCAmelCase_   :       Optional[Any]    							=emission.size(0      )
					lowerCAmelCase_   :       List[str]    							=len(UpperCamelCase_      )

					# Trellis has extra diemsions for both time axis and tokens.
					# The extra dim for tokens represents <SoS> (start-of-sentence)
					# The extra dim for time axis is for simplification of the code.
					lowerCAmelCase_   :       List[str]    							=torch.full((num_frames + 1, num_tokens + 1)					,						-float('''inf'''      )      )
					lowerCAmelCase_   :       List[str]    							=0
					for t in range(UpperCamelCase_      ):
							lowerCAmelCase_   :       Optional[int]    							=torch.maximum(
							    # Score for staying at the same token
							    trellis[t, 1:] + emission[t, blank_id]					,						trellis[t, :-1] + emission[t, tokens]					,						)
					return trellis

			lowerCAmelCase_   :       Union[str, Any]    							=get_trellis(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )

			@dataclass
			class 							_snake_case     :
				"""simple docstring"""





				_UpperCamelCase							:  int
				_UpperCamelCase							:  int
				_UpperCamelCase							:  float

			def backtrack(UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: str=0      ):
					lowerCAmelCase_   :       List[Any]    							=trellis.size(1      ) - 1
					lowerCAmelCase_   :       List[Any]    							=torch.argmax(trellis[:, j]      ).item()

					lowerCAmelCase_   :       Dict    							=[]
					for t in range(UpperCamelCase_					,						0					,						-1      ):
							# 1. Figure out if the current position was stay or change
							# Note (again):
							# `emission[J-1]` is the emission at time frame `J` of trellis dimension.
							# Score for token staying the same from time frame J-1 to T.
							lowerCAmelCase_   :       str    							=trellis[t - 1, j] + emission[t - 1, blank_id]
							# Score for token changing from C-1 at T-1 to J at T.
							lowerCAmelCase_   :       Optional[int]    							=trellis[t - 1, j - 1] + emission[t - 1, tokens[j - 1]]

							# 2. Store the path with frame-wise probability.
							lowerCAmelCase_   :       Dict    							=emission[t - 1, tokens[j - 1] if changed > stayed else 0].exp().item()
							# Return token index and time index in non-trellis coordinate.
							path.append(Point(j - 1					,						t - 1					,						UpperCamelCase_      )      )

							# 3. Update the token
							if changed > stayed:
									j -= 1
									if j == 0:
											break
					else:
							raise ValueError('''Failed to align'''      )
					return path[::-1]

			lowerCAmelCase_   :       Optional[int]    							=backtrack(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )

			@dataclass
			class 							_snake_case     :
				"""simple docstring"""





				_UpperCamelCase							:  str
				_UpperCamelCase							:  int
				_UpperCamelCase							:  int
				_UpperCamelCase							:  float




				def __repr__(						self				: str      ):
						return F'{self.label}\t{self.score:4.2f}\t{self.start*20:5d}\t{self.end*20:5d}'





				@property
				def 	__A      (						self				: int      ):
						return self.end - self.start

			def merge_repeats(UpperCamelCase_				: str      ):
					lowerCAmelCase_							,		lowerCAmelCase_   :       List[Any]    							=0, 0
					lowerCAmelCase_   :       int    							=[]
					while ia < len(UpperCamelCase_      ):
							while ia < len(UpperCamelCase_      ) and path[ia].token_index == path[ia].token_index:
									ia += 1
							lowerCAmelCase_   :       str    							=sum(path[k].score for k in range(UpperCamelCase_					,						UpperCamelCase_      )      ) / (ia - ia)
							segments.append(
							    Segment(
							        transcript[path[ia].token_index]					,						path[ia].time_index					,						path[ia - 1].time_index + 1					,						UpperCamelCase_					,						)      )
							lowerCAmelCase_   :       List[str]    							=ia
					return segments

			lowerCAmelCase_   :       Union[str, Any]    							=merge_repeats(UpperCamelCase_      )
			with open(item['''out_path''']					,						'''w'''      ) as out_align:
					for seg in segments:
							out_align.write(str(UpperCamelCase_      ) + '''\n'''      )





	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Dict      ):
			if not os.path.exists(UpperCamelCase_      ):
					os.makedirs(UpperCamelCase_      )

			# load text file
			lowerCAmelCase_   :       Optional[Any]    							=open(UpperCamelCase_					,						encoding='''utf8'''      ).readlines()

			lowerCAmelCase_   :       Optional[Any]    							=[]
			for line in lines:
					if len(line.strip().split('''\t'''      )      ) != 2:
							print('''Script must be in format: 00001  this is my sentence'''      )
							exit()

					lowerCAmelCase_							,		lowerCAmelCase_   :       int    							=line.strip().split('''\t'''      )
					lowerCAmelCase_   :       str    							=os.path.join(UpperCamelCase_					,						wav_name + '''.wav'''      )
					lowerCAmelCase_   :       Union[str, Any]    							=os.path.join(UpperCamelCase_					,						wav_name + '''.txt'''      )

					items.append({'''sent''': sentence, '''wav_path''': wav_path, '''out_path''': out_path}      )
			print('''Number of samples found in script file'''					,						len(UpperCamelCase_      )      )

			for item in tqdm(UpperCamelCase_      ):
					self.align_single_sample(UpperCamelCase_      )







def 		SCREAMING_SNAKE_CASE__					(							):
		lowerCAmelCase_   :       List[str]    							=argparse.ArgumentParser()

		parser.add_argument(
		    '''--model_name'''  ,					type=_SCREAMING_SNAKE_CASE  ,					default='''arijitx/wav2vec2-xls-r-300m-bengali'''  ,					help='''wav2vec model name'''  )
		parser.add_argument('''--wav_dir'''  ,					type=_SCREAMING_SNAKE_CASE  ,					default='''./wavs'''  ,					help='''directory containing wavs'''  )
		parser.add_argument('''--text_file'''  ,					type=_SCREAMING_SNAKE_CASE  ,					default='''script.txt'''  ,					help='''file containing text'''  )
		parser.add_argument('''--input_wavs_sr'''  ,					type=_SCREAMING_SNAKE_CASE  ,					default=1_6000  ,					help='''sampling rate of input audios'''  )
		parser.add_argument(
		    '''--output_dir'''  ,					type=_SCREAMING_SNAKE_CASE  ,					default='''./out_alignment'''  ,					help='''output directory containing the alignment files'''  )
		parser.add_argument('''--cuda'''  ,					action='''store_true'''  )

		lowerCAmelCase_   :       Tuple    							=parser.parse_args()

		lowerCAmelCase_   :       Union[str, Any]    							=WavaVecaAligner(args.model_name  ,					args.input_wavs_sr  ,					args.cuda  )
		aligner.align_data(args.wav_dir  ,					args.text_file  ,					args.output_dir  )


if __name__ == "__main__":
							main()








'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFXLMForMultipleChoice,
							    TFXLMForQuestionAnsweringSimple,
							    TFXLMForSequenceClassification,
							    TFXLMForTokenClassification,
							    TFXLMModel,
							    TFXLMWithLMHeadModel,
							    XLMConfig,
							)

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: str					,						UpperCamelCase_				: Union[str, Any]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=parent
			lowerCAmelCase_   :       Any    							=13
			lowerCAmelCase_   :       str    							=7
			lowerCAmelCase_   :       Optional[Any]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       List[str]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Dict    							=True
			lowerCAmelCase_   :       Union[str, Any]    							=False
			lowerCAmelCase_   :       List[Any]    							=False
			lowerCAmelCase_   :       Optional[int]    							=False
			lowerCAmelCase_   :       Union[str, Any]    							=2
			lowerCAmelCase_   :       List[str]    							=99
			lowerCAmelCase_   :       Optional[int]    							=0
			lowerCAmelCase_   :       Optional[int]    							=32
			lowerCAmelCase_   :       Dict    							=2
			lowerCAmelCase_   :       Dict    							=4
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=512
			lowerCAmelCase_   :       Dict    							=16
			lowerCAmelCase_   :       List[Any]    							=2
			lowerCAmelCase_   :       Optional[int]    							=0.0_2
			lowerCAmelCase_   :       int    							=3
			lowerCAmelCase_   :       int    							=4
			lowerCAmelCase_   :       Union[str, Any]    							='''last'''
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Any    							=None
			lowerCAmelCase_   :       int    							=0




	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       List[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size      )
			lowerCAmelCase_   :       Union[str, Any]    							=random_attention_mask([self.batch_size, self.seq_length]					,						dtype=tf.floataa      )

			lowerCAmelCase_   :       List[str]    							=None
			if self.use_input_lengths:
					lowerCAmelCase_   :       Optional[Any]    							=(
					    ids_tensor([self.batch_size]					,						vocab_size=2      ) + self.seq_length - 2
					)  # small variation of seq_length

			lowerCAmelCase_   :       str    							=None
			if self.use_token_type_ids:
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.n_langs      )

			lowerCAmelCase_   :       Optional[int]    							=None
			lowerCAmelCase_   :       str    							=None
			lowerCAmelCase_   :       Dict    							=None
			if self.use_labels:
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						self.type_sequence_label_size      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size, self.seq_length]					,						self.num_labels      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						2					,						dtype=tf.floataa      )
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size]					,						self.num_choices      )

			lowerCAmelCase_   :       Tuple    							=XLMConfig(
			    vocab_size=self.vocab_size					,						n_special=self.n_special					,						emb_dim=self.hidden_size					,						n_layers=self.num_hidden_layers					,						n_heads=self.num_attention_heads					,						dropout=self.hidden_dropout_prob					,						attention_dropout=self.attention_probs_dropout_prob					,						gelu_activation=self.gelu_activation					,						sinusoidal_embeddings=self.sinusoidal_embeddings					,						asm=self.asm					,						causal=self.causal					,						n_langs=self.n_langs					,						max_position_embeddings=self.max_position_embeddings					,						initializer_range=self.initializer_range					,						summary_type=self.summary_type					,						use_proj=self.use_proj					,						bos_token_id=self.bos_token_id					,						)

			return (
			    config,
			    input_ids,
			    token_type_ids,
			    input_lengths,
			    sequence_labels,
			    token_labels,
			    is_impossible_labels,
			    choice_labels,
			    input_mask,
			)




	def 	__A      (						self				: Any					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Tuple					,						):
			lowerCAmelCase_   :       int    							=TFXLMModel(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Union[str, Any]    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       Union[str, Any]    							=[input_ids, input_mask]
			lowerCAmelCase_   :       List[Any]    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.last_hidden_state.shape					,						(self.batch_size, self.seq_length, self.hidden_size)      )




	def 	__A      (						self				: List[Any]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: List[Any]					,						):
			lowerCAmelCase_   :       List[str]    							=TFXLMWithLMHeadModel(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Tuple    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       int    							=outputs

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.vocab_size)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=TFXLMForQuestionAnsweringSimple(UpperCamelCase_      )

			lowerCAmelCase_   :       str    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       Optional[Any]    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.start_logits.shape					,						(self.batch_size, self.seq_length)      )
			self.parent.assertEqual(result.end_logits.shape					,						(self.batch_size, self.seq_length)      )




	def 	__A      (						self				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[Any]    							=TFXLMForSequenceClassification(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       int    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)      )




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=self.num_labels
			lowerCAmelCase_   :       int    							=TFXLMForTokenClassification(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
			lowerCAmelCase_   :       str    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.num_labels)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[str]    							=self.num_choices
			lowerCAmelCase_   :       Tuple    							=TFXLMForMultipleChoice(config=UpperCamelCase_      )
			lowerCAmelCase_   :       str    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Union[str, Any]    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Any    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Optional[Any]    							={
			    '''input_ids''': multiple_choice_inputs_ids,
			    '''attention_mask''': multiple_choice_input_mask,
			    '''token_type_ids''': multiple_choice_token_type_ids,
			}
			lowerCAmelCase_   :       Any    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_choices)      )





	def 	__A      (						self				: Union[str, Any]      ):
			lowerCAmelCase_   :       List[Any]    							=self.prepare_config_and_inputs()
			(
			    (
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		
			)   :       List[str]    							=config_and_inputs
			lowerCAmelCase_   :       List[Any]    							={
			    '''input_ids''': input_ids,
			    '''token_type_ids''': token_type_ids,
			    '''langs''': token_type_ids,
			    '''lengths''': input_lengths,
			}
			return config, inputs_dict







@require_tf
class 							_snake_case     (  lowerCAmelCase_						,    lowerCAmelCase_						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Union[str, Any]								=		(
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	_UpperCamelCase							:  Union[str, Any]								=		(
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	_UpperCamelCase							:  List[str]								=		(
	    {
	        '''feature-extraction''': TFXLMModel,
	        '''fill-mask''': TFXLMWithLMHeadModel,
	        '''question-answering''': TFXLMForQuestionAnsweringSimple,
	        '''text-classification''': TFXLMForSequenceClassification,
	        '''text-generation''': TFXLMWithLMHeadModel,
	        '''token-classification''': TFXLMForTokenClassification,
	        '''zero-shot''': TFXLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	_UpperCamelCase							:  Optional[int]								=		False
	_UpperCamelCase							:  int								=		False




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[str]      ):
			if (
			    pipeline_test_casse_name == "QAPipelineTests"
			    and tokenizer_name is not None
			    and not tokenizer_name.endswith('''Fast'''      )
			):
					# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
					# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
					# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
					return True

			return False




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=TFXLMModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase_					,						emb_dim=37      )




	def 	__A      (						self				: Union[str, Any]      ):
			self.config_tester.run_common_tests()




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       int    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*UpperCamelCase_      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase_      )




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase_      )





	@slow
	def 	__A      (						self				: List[Any]      ):
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase_   :       List[str]    							=TFXLMModel.from_pretrained(UpperCamelCase_      )
					self.assertIsNotNone(UpperCamelCase_      )







@require_tf
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	@slow
	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       Any    							=TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''      )
			lowerCAmelCase_   :       List[str]    							=tf.convert_to_tensor([[14, 447]]					,						dtype=tf.intaa      )  # the president
			lowerCAmelCase_   :       List[Any]    							=[
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			]  # the president the president the president the president the president the president the president the president the president the president
			# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
			lowerCAmelCase_   :       Optional[int]    							=model.generate(UpperCamelCase_					,						do_sample=UpperCamelCase_      )
			self.assertListEqual(output_ids[0].numpy().tolist()					,						UpperCamelCase_      )






