


'''simple docstring'''


import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


UpperCAmelCase_	:     List[str]							     =	'\nHugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.\n\nIn March 2021, Hugging Face raised $40 million in a Series B funding round.[3]\n\nOn April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]\n'





class 					lowercase__						(		unittest.TestCase  ,  _snake_case      ):





							'''simple docstring'''


							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   load_tool("""summarization"""						)
											self.tool.setup()
											_SCREAMING_SNAKE_CASE				: List[str]  	=   load_tool("""summarization"""					,      remote=__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.tool(__snake_case						)
											self.assertEqual(
											    __snake_case					,      """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""					,      )






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   self.remote_tool(__snake_case						)
											self.assertEqual(
											    __snake_case					,      """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""					,      )






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   self.tool(text=__snake_case						)
											self.assertEqual(
											    __snake_case					,      """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""					,      )






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: str  	=   self.remote_tool(text=__snake_case						)
											self.assertEqual(
											    __snake_case					,      """Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."""					,      )








'''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 					lowercase__						:





							'''simple docstring'''


							def __init__(					self					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Dict  	=   parent
											_SCREAMING_SNAKE_CASE				: Any  	=   13
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   7
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: str  	=   True
											_SCREAMING_SNAKE_CASE				: Dict  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   False
											_SCREAMING_SNAKE_CASE				: Tuple  	=   False
											_SCREAMING_SNAKE_CASE				: Any  	=   False
											_SCREAMING_SNAKE_CASE				: Dict  	=   2
											_SCREAMING_SNAKE_CASE				: str  	=   99
											_SCREAMING_SNAKE_CASE				: Any  	=   0
											_SCREAMING_SNAKE_CASE				: List[str]  	=   32
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   2
											_SCREAMING_SNAKE_CASE				: List[str]  	=   4
											_SCREAMING_SNAKE_CASE				: List[str]  	=   0.1
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   0.1
											_SCREAMING_SNAKE_CASE				: int  	=   512
											_SCREAMING_SNAKE_CASE				: List[str]  	=   16
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   2
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   0.02
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   3
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   4
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   """last"""
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   True
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   None
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   0






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   random_attention_mask([self.batch_size, self.seq_length]					,      dtype=tf.floataa						)

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

											_SCREAMING_SNAKE_CASE				: Tuple  	=   None
											if self.use_token_type_ids:
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   ids_tensor([self.batch_size, self.seq_length]					,      self.n_langs						)

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

											_SCREAMING_SNAKE_CASE				: Dict  	=   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					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMModel(config=__snake_case						)
											_SCREAMING_SNAKE_CASE				: int  	=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: int  	=   model(__snake_case						)

											_SCREAMING_SNAKE_CASE				: str  	=   [input_ids, input_mask]
											_SCREAMING_SNAKE_CASE				: str  	=   model(__snake_case						)
											self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size)						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMWithLMHeadModel(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   model(__snake_case						)

											_SCREAMING_SNAKE_CASE				: str  	=   outputs

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






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: List[str]  	=   TFXLMForQuestionAnsweringSimple(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Any  	=   {"""input_ids""": input_ids, """lengths""": input_lengths}

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   model(__snake_case						)

											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					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Dict  	=   TFXLMForSequenceClassification(__snake_case						)

											_SCREAMING_SNAKE_CASE				: int  	=   {"""input_ids""": input_ids, """lengths""": input_lengths}

											_SCREAMING_SNAKE_CASE				: List[str]  	=   model(__snake_case						)

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






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   self.num_labels
											_SCREAMING_SNAKE_CASE				: Dict  	=   TFXLMForTokenClassification(config=__snake_case						)
											_SCREAMING_SNAKE_CASE				: Any  	=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
											_SCREAMING_SNAKE_CASE				: Dict  	=   model(__snake_case						)
											self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.num_labels)						)






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      ):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.num_choices
											_SCREAMING_SNAKE_CASE				: List[str]  	=   TFXLMForMultipleChoice(config=__snake_case						)
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   tf.tile(tf.expand_dims(__snake_case					,      1						)					,      (1, self.num_choices, 1)						)
											_SCREAMING_SNAKE_CASE				: List[str]  	=   tf.tile(tf.expand_dims(__snake_case					,      1						)					,      (1, self.num_choices, 1)						)
											_SCREAMING_SNAKE_CASE				: int  	=   tf.tile(tf.expand_dims(__snake_case					,      1						)					,      (1, self.num_choices, 1)						)
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   {
											    """input_ids""": multiple_choice_inputs_ids,
											    """attention_mask""": multiple_choice_input_mask,
											    """token_type_ids""": multiple_choice_token_type_ids,
											}
											_SCREAMING_SNAKE_CASE				: Any  	=   model(__snake_case						)
											self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_choices)						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.prepare_config_and_inputs()
											(
											    (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, (
											    _SCREAMING_SNAKE_CASE
											)	, 
											)				: Tuple  	=   config_and_inputs
											_SCREAMING_SNAKE_CASE				: Tuple  	=   {
											    """input_ids""": input_ids,
											    """token_type_ids""": token_type_ids,
											    """langs""": token_type_ids,
											    """lengths""": input_lengths,
											}
											return config, inputs_dict





@require_tf
class 					lowercase__						(		_snake_case  ,  _snake_case  ,  unittest.TestCase      ):





							'''simple docstring'''


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






							def UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case					,      __snake_case						):
											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						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   TFXLMModelTester(self						)
											_SCREAMING_SNAKE_CASE				: List[str]  	=   ConfigTester(self					,      config_class=__snake_case					,      emb_dim=37						)






							def UpperCAmelCase_			(					self						):
											self.config_tester.run_common_tests()






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: int  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_model(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_lm_head(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_qa(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_sequence_classif(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Tuple  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_token_classification(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_xlm_for_multiple_choice(*__snake_case						)






							@slow
							def UpperCAmelCase_			(					self						):
											for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE				: int  	=   TFXLMModel.from_pretrained(__snake_case						)
															self.assertIsNotNone(__snake_case						)





@require_tf
class 					lowercase__						(		unittest.TestCase      ):





							'''simple docstring'''


							@slow
							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""						)
											_SCREAMING_SNAKE_CASE				: Any  	=   tf.convert_to_tensor([[14, 447]]					,      dtype=tf.intaa						)  # the president
											_SCREAMING_SNAKE_CASE				: Union[str, 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
											_SCREAMING_SNAKE_CASE				: Dict  	=   model.generate(__snake_case					,      do_sample=__snake_case						)
											self.assertListEqual(output_ids[0].numpy().tolist()					,      __snake_case						)




