



'''simple docstring'''






import argparse
import logging
import os
import sys
from collections import namedtuple

import torch
from modeling_bertabs import BertAbs, build_predictor
from torch.utils.data import DataLoader, SequentialSampler
from tqdm import tqdm

from transformers import BertTokenizer

from .utils_summarization import (
    CNNDMDataset,
    build_mask,
    compute_token_type_ids,
    encode_for_summarization,
    truncate_or_pad,
)


A_				:					Any							=      logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.INFO)


A_				:					List[str]							=      namedtuple("""Batch""", ["""document_names""", """batch_size""", """src""", """segs""", """mask_src""", """tgt_str"""])




def        snake_case_   (	lowerCAmelCase_						)->						Optional[int]:





       '''simple docstring'''


       _UpperCAmelCase    :		Tuple     	=					BertTokenizer.from_pretrained("""bert-base-uncased"""			,  do_lower_case=lowerCAmelCase_						)
       _UpperCAmelCase    :		Dict     	=					BertAbs.from_pretrained("""remi/bertabs-finetuned-extractive-abstractive-summarization"""						)
       model.to(args.device						)
       model.eval()

       _UpperCAmelCase    :		Union[str, Any]     	=					{
           """BOS""": tokenizer.vocab["""[unused0]"""],
           """EOS""": tokenizer.vocab["""[unused1]"""],
           """PAD""": tokenizer.vocab["""[PAD]"""],
       }

       if args.compute_rouge:
              _UpperCAmelCase    :		Optional[Any]     	=					[]
              _UpperCAmelCase    :		Optional[int]     	=					[]

              import nltk
              import rouge

              nltk.download("""punkt"""						)
              _UpperCAmelCase    :		Optional[Any]     	=					rouge.Rouge(
                  metrics=["""rouge-n""", """rouge-l"""]			,  max_n=2			,  limit_length=lowerCAmelCase_			,  length_limit=args.beam_size			,  length_limit_type="""words"""			,  apply_avg=lowerCAmelCase_			,  apply_best=lowerCAmelCase_			,  alpha=0.5			,  weight_factor=1.2			,  stemming=lowerCAmelCase_			,  )

       # these (unused) arguments are defined to keep the compatibility
       # with the legacy code and will be deleted in a next iteration.
       _UpperCAmelCase    :		Optional[int]     	=					""""""
       _UpperCAmelCase    :		Any     	=					""""""

       _UpperCAmelCase    :		List[Any]     	=					build_data_iterator(lowerCAmelCase_			,  lowerCAmelCase_						)
       _UpperCAmelCase    :		Any     	=					build_predictor(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_						)

       logger.info("""***** Running evaluation *****"""						)
       logger.info("""  Number examples = %d"""			,  len(data_iterator.dataset						)						)
       logger.info("""  Batch size = %d"""			,  args.batch_size						)
       logger.info(""""""						)
       logger.info("""***** Beam Search parameters *****"""						)
       logger.info("""  Beam size = %d"""			,  args.beam_size						)
       logger.info("""  Minimum length = %d"""			,  args.min_length						)
       logger.info("""  Maximum length = %d"""			,  args.max_length						)
       logger.info("""  Alpha (length penalty) = %.2f"""			,  args.alpha						)
       logger.info("""  Trigrams %s be blocked"""			,  ("""will""" if args.block_trigram else """will NOT""")						)

       for batch in tqdm(lowerCAmelCase_						):
              _UpperCAmelCase    :		Optional[int]     	=					predictor.translate_batch(lowerCAmelCase_						)
              _UpperCAmelCase    :		Dict     	=					predictor.from_batch(lowerCAmelCase_						)
              _UpperCAmelCase    :		Union[str, Any]     	=					[format_summary(lowerCAmelCase_						) for t in translations]
              save_summaries(lowerCAmelCase_			,  args.summaries_output_dir			,  batch.document_names						)

              if args.compute_rouge:
                     reference_summaries += batch.tgt_str
                     generated_summaries += summaries

       if args.compute_rouge:
              _UpperCAmelCase    :		Dict     	=					rouge_evaluator.get_scores(lowerCAmelCase_			,  lowerCAmelCase_						)
              _UpperCAmelCase    :		Optional[int]     	=					format_rouge_scores(lowerCAmelCase_						)
              save_rouge_scores(lowerCAmelCase_						)
              print(lowerCAmelCase_						)




def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_						)->						Any:





       '''simple docstring'''


       for summary, document_name in zip(lowerCAmelCase_			,  lowerCAmelCase_						):
              # Prepare the summary file's name
              if "." in document_name:
                     _UpperCAmelCase    :		Union[str, Any]     	=					""".""".join(document_name.split("""."""						)[:-1]						)
                     _UpperCAmelCase    :		Tuple     	=					document_name.split("""."""						)[-1]
                     _UpperCAmelCase    :		Dict     	=					bare_document_name + """_summary.""" + extension
              else:
                     _UpperCAmelCase    :		Optional[int]     	=					document_name + """_summary"""

              _UpperCAmelCase    :		Union[str, Any]     	=					os.path.join(lowerCAmelCase_			,  lowerCAmelCase_						)
              with open(lowerCAmelCase_			,  """w"""						) as output:
                     output.write(lowerCAmelCase_						)




def        snake_case_   (	lowerCAmelCase_						)->						int:





       '''simple docstring'''


       _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		str     	=					translation
       _UpperCAmelCase    :		List[str]     	=					(
           raw_summary.replace("""[unused0]"""			,  """"""						)
           .replace("""[unused3]"""			,  """"""						)
           .replace("""[PAD]"""			,  """"""						)
           .replace("""[unused1]"""			,  """"""						)
           .replace(R""" +"""			,  """ """						)
           .replace(""" [unused2] """			,  """. """						)
           .replace("""[unused2]"""			,  """"""						)
           .strip()
       )

       return summary




def        snake_case_   (	lowerCAmelCase_						)->						Tuple:





       '''simple docstring'''


       return """\n
****** ROUGE SCORES ******

** ROUGE 1
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE 2
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}

** ROUGE L
F1        >> {:.3f}
Precision >> {:.3f}
Recall    >> {:.3f}""".format(
           scores["""rouge-1"""]["""f"""]			,  scores["""rouge-1"""]["""p"""]			,  scores["""rouge-1"""]["""r"""]			,  scores["""rouge-2"""]["""f"""]			,  scores["""rouge-2"""]["""p"""]			,  scores["""rouge-2"""]["""r"""]			,  scores["""rouge-l"""]["""f"""]			,  scores["""rouge-l"""]["""p"""]			,  scores["""rouge-l"""]["""r"""]			,  )




def        snake_case_   (	lowerCAmelCase_						)->						Any:





       '''simple docstring'''


       with open("""rouge_scores.txt"""			,  """w"""						) as output:
              output.write(lowerCAmelCase_						)




def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_						)->						Optional[int]:





       '''simple docstring'''


       _UpperCAmelCase    :		Dict     	=					load_and_cache_examples(lowerCAmelCase_			,  lowerCAmelCase_						)
       _UpperCAmelCase    :		Union[str, Any]     	=					SequentialSampler(lowerCAmelCase_						)

       def collate_fn(lowerCAmelCase_						):
              return collate(lowerCAmelCase_			,  lowerCAmelCase_			,  block_size=512			,  device=args.device						)

       _UpperCAmelCase    :		Dict     	=					DataLoader(
           lowerCAmelCase_			,  sampler=lowerCAmelCase_			,  batch_size=args.batch_size			,  collate_fn=lowerCAmelCase_			,  )

       return iterator




def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_						)->						Optional[int]:





       '''simple docstring'''


       _UpperCAmelCase    :		Dict     	=					CNNDMDataset(args.documents_dir						)
       return dataset




def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_						)->						List[str]:





       '''simple docstring'''


       _UpperCAmelCase    :		List[str]     	=					[x for x in data if not len(x[1]						) == 0]  # remove empty_files
       _UpperCAmelCase    :		str     	=					[name for name, _, _ in data]
       _UpperCAmelCase    :		List[str]     	=					[""" """.join(lowerCAmelCase_						) for _, _, summary_list in data]

       _UpperCAmelCase    :		Optional[int]     	=					[encode_for_summarization(lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_						) for _, story, summary in data]
       _UpperCAmelCase    :		Union[str, Any]     	=					torch.tensor(
           [truncate_or_pad(lowerCAmelCase_			,  lowerCAmelCase_			,  tokenizer.pad_token_id						) for story, _ in encoded_text]						)
       _UpperCAmelCase    :		Tuple     	=					compute_token_type_ids(lowerCAmelCase_			,  tokenizer.cls_token_id						)
       _UpperCAmelCase    :		Tuple     	=					build_mask(lowerCAmelCase_			,  tokenizer.pad_token_id						)

       _UpperCAmelCase    :		List[Any]     	=					Batch(
           document_names=lowerCAmelCase_			,  batch_size=len(lowerCAmelCase_						)			,  src=encoded_stories.to(lowerCAmelCase_						)			,  segs=encoder_token_type_ids.to(lowerCAmelCase_						)			,  mask_src=encoder_mask.to(lowerCAmelCase_						)			,  tgt_str=lowerCAmelCase_			,  )

       return batch




def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_						)->						int:





       '''simple docstring'''


       _UpperCAmelCase    :		Optional[Any]     	=					summary_tokens.to("""cpu"""						).numpy()
       _UpperCAmelCase    :		Optional[Any]     	=					tokenizer.decode(lowerCAmelCase_						)
       _UpperCAmelCase    :		Union[str, Any]     	=					summary.split("""."""						)
       _UpperCAmelCase    :		Optional[int]     	=					[s + """.""" for s in sentences]
       return sentences




def        snake_case_   (	)->						Any:





       '''simple docstring'''


       _UpperCAmelCase    :		int     	=					argparse.ArgumentParser()
       parser.add_argument(
           """--documents_dir"""			,  default=lowerCAmelCase_			,  type=lowerCAmelCase_			,  required=lowerCAmelCase_			,  help="""The folder where the documents to summarize are located."""			,  )
       parser.add_argument(
           """--summaries_output_dir"""			,  default=lowerCAmelCase_			,  type=lowerCAmelCase_			,  required=lowerCAmelCase_			,  help="""The folder in wich the summaries should be written. Defaults to the folder where the documents are"""			,  )
       parser.add_argument(
           """--compute_rouge"""			,  default=lowerCAmelCase_			,  type=lowerCAmelCase_			,  required=lowerCAmelCase_			,  help="""Compute the ROUGE metrics during evaluation. Only available for the CNN/DailyMail dataset."""			,  )
       # EVALUATION options
       parser.add_argument(
           """--no_cuda"""			,  default=lowerCAmelCase_			,  type=lowerCAmelCase_			,  help="""Whether to force the execution on CPU."""			,  )
       parser.add_argument(
           """--batch_size"""			,  default=4			,  type=lowerCAmelCase_			,  help="""Batch size per GPU/CPU for training."""			,  )
       # BEAM SEARCH arguments
       parser.add_argument(
           """--min_length"""			,  default=50			,  type=lowerCAmelCase_			,  help="""Minimum number of tokens for the summaries."""			,  )
       parser.add_argument(
           """--max_length"""			,  default=200			,  type=lowerCAmelCase_			,  help="""Maixmum number of tokens for the summaries."""			,  )
       parser.add_argument(
           """--beam_size"""			,  default=5			,  type=lowerCAmelCase_			,  help="""The number of beams to start with for each example."""			,  )
       parser.add_argument(
           """--alpha"""			,  default=0.9_5			,  type=lowerCAmelCase_			,  help="""The value of alpha for the length penalty in the beam search."""			,  )
       parser.add_argument(
           """--block_trigram"""			,  default=lowerCAmelCase_			,  type=lowerCAmelCase_			,  help="""Whether to block the existence of repeating trigrams in the text generated by beam search."""			,  )
       _UpperCAmelCase    :		Any     	=					parser.parse_args()

       # Select device (distibuted not available)
       _UpperCAmelCase    :		Optional[int]     	=					torch.device("""cuda""" if torch.cuda.is_available() and not args.no_cuda else """cpu"""						)

       # Check the existence of directories
       if not args.summaries_output_dir:
              _UpperCAmelCase    :		Optional[Any]     	=					args.documents_dir

       if not documents_dir_is_valid(args.documents_dir						):
              raise FileNotFoundError(
                  """We could not find the directory you specified for the documents to summarize, or it was empty. Please"""
                  """ specify a valid path."""						)
       os.makedirs(args.summaries_output_dir			,  exist_ok=lowerCAmelCase_						)

       evaluate(lowerCAmelCase_						)




def        snake_case_   (	lowerCAmelCase_						)->						Union[str, Any]:





       '''simple docstring'''


       if not os.path.exists(lowerCAmelCase_						):
              return False

       _UpperCAmelCase    :		Any     	=					os.listdir(lowerCAmelCase_						)
       if len(lowerCAmelCase_						) == 0:
              return False

       return True


if __name__ == "__main__":
   main()









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							:	Optional[Any]   , __lowerCamelCase							:	Any   , )   ->	Any:
							a       =     parent
							a       =     13
							a       =     7
							a       =     True
							a       =     True
							a       =     True
							a       =     True
							a       =     True
							a       =     False
							a       =     False
							a       =     False
							a       =     2
							a       =     99
							a       =     0
							a       =     32
							a       =     2
							a       =     4
							a       =     0.1
							a       =     0.1
							a       =     5_12
							a       =     16
							a       =     2
							a       =     0.02
							a       =     3
							a       =     4
							a       =     "last"
							a       =     True
							a       =     None
							a       =     0





				def 				__UpperCAmelCase				( self							:	int				)   ->	Tuple:
							a       =     ids_tensor([self.batch_size, self.seq_length]   , self.vocab_size				)
							a       =     random_attention_mask([self.batch_size, self.seq_length]   , dtype=tf.floataa				)

							a       =     None
							if self.use_input_lengths:
										a       =     (
										    ids_tensor([self.batch_size]   , vocab_size=2				) + self.seq_length - 2
										)  # small variation of seq_length

							a       =     None
							if self.use_token_type_ids:
										a       =     ids_tensor([self.batch_size, self.seq_length]   , self.n_langs				)

							a       =     None
							a       =     None
							a       =     None
							if self.use_labels:
										a       =     ids_tensor([self.batch_size]   , self.type_sequence_label_size				)
										a       =     ids_tensor([self.batch_size, self.seq_length]   , self.num_labels				)
										a       =     ids_tensor([self.batch_size]   , 2   , dtype=tf.floataa				)
										a       =     ids_tensor([self.batch_size]   , self.num_choices				)

							a       =     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 				__UpperCAmelCase				( self							:	List[str]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Any   , )   ->	Union[str, Any]:
							a       =     TFXLMModel(config=__lowerCamelCase				)
							a       =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
							a       =     model(__lowerCamelCase				)

							a       =     [input_ids, input_mask]
							a       =     model(__lowerCamelCase				)
							self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)				)





				def 				__UpperCAmelCase				( self							:	Union[str, Any]   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	Dict   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Any   , )   ->	Optional[Any]:
							a       =     TFXLMWithLMHeadModel(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
							a       =     model(__lowerCamelCase				)

							a       =     outputs

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





				def 				__UpperCAmelCase				( self							:	Tuple   , __lowerCamelCase							:	Dict   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	List[Any]   , )   ->	int:
							a       =     TFXLMForQuestionAnsweringSimple(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths}

							a       =     model(__lowerCamelCase				)

							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 				__UpperCAmelCase				( self							:	Dict   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	int   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	Optional[int]   , )   ->	Optional[int]:
							a       =     TFXLMForSequenceClassification(__lowerCamelCase				)

							a       =     {"input_ids": input_ids, "lengths": input_lengths}

							a       =     model(__lowerCamelCase				)

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





				def 				__UpperCAmelCase				( self							:	Any   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Union[str, Any]   , )   ->	Optional[Any]:
							a       =     self.num_labels
							a       =     TFXLMForTokenClassification(config=__lowerCamelCase				)
							a       =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
							a       =     model(__lowerCamelCase				)
							self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.num_labels)				)





				def 				__UpperCAmelCase				( self							:	Any   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Union[str, Any]   , __lowerCamelCase							:	Dict   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	str   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	str   , __lowerCamelCase							:	List[str]   , __lowerCamelCase							:	Dict   , )   ->	List[Any]:
							a       =     self.num_choices
							a       =     TFXLMForMultipleChoice(config=__lowerCamelCase				)
							a       =     tf.tile(tf.expand_dims(__lowerCamelCase   , 1				)   , (1, self.num_choices, 1)				)
							a       =     tf.tile(tf.expand_dims(__lowerCamelCase   , 1				)   , (1, self.num_choices, 1)				)
							a       =     tf.tile(tf.expand_dims(__lowerCamelCase   , 1				)   , (1, self.num_choices, 1)				)
							a       =     {
							    "input_ids": multiple_choice_inputs_ids,
							    "attention_mask": multiple_choice_input_mask,
							    "token_type_ids": multiple_choice_token_type_ids,
							}
							a       =     model(__lowerCamelCase				)
							self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_choices)				)





				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	str:
							a       =     self.prepare_config_and_inputs()
							(
							    (
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						(
							    a
							)       ,						
							)       =     config_and_inputs
							a       =     {
							    "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__				(_UpperCamelCase       ,			_UpperCamelCase       ,			unittest.TestCase  ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			:				int									=   (
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE_			:				List[str]									=   (
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				SCREAMING_SNAKE_CASE_			:				List[Any]									=   (
				    {
				        """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 {}
				)
				SCREAMING_SNAKE_CASE_			:				Tuple									=   False
				SCREAMING_SNAKE_CASE_			:				Dict									=   False





				def 				__UpperCAmelCase				( self							:	Any   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	List[Any]   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	Optional[int]   , __lowerCamelCase							:	List[Any]				)   ->	Dict:
							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 				__UpperCAmelCase				( self							:	Tuple				)   ->	Tuple:
							a       =     TFXLMModelTester(self				)
							a       =     ConfigTester(self   , config_class=__lowerCamelCase   , emb_dim=37				)





				def 				__UpperCAmelCase				( self							:	List[str]				)   ->	Optional[int]:
							self.config_tester.run_common_tests()





				def 				__UpperCAmelCase				( self							:	Dict				)   ->	List[Any]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_model(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Tuple				)   ->	Dict:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_lm_head(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	Dict:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_qa(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	Optional[int]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_sequence_classif(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	Optional[Any]:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_token_classification(*__lowerCamelCase				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	str:
							a       =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_xlm_for_multiple_choice(*__lowerCamelCase				)





				@slow
				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	List[Any]:
							for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										a       =     TFXLMModel.from_pretrained(__lowerCamelCase				)
										self.assertIsNotNone(__lowerCamelCase				)




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



				@slow
				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	str:
							a       =     TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"				)
							a       =     tf.convert_to_tensor([[14, 4_47]]   , dtype=tf.intaa				)  # the president
							a       =     [
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							    14,
							    4_47,
							]  # 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
							a       =     model.generate(__lowerCamelCase   , do_sample=__lowerCamelCase				)
							self.assertListEqual(output_ids[0].numpy().tolist()   , __lowerCamelCase				)






