

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



 """simple docstring"""



 def __init__(	self      : str      ,							__SCREAMING_SNAKE_CASE      : int      ,							)						->				List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   parent
      __SCREAMING_SNAKE_CASE						     =   13
      __SCREAMING_SNAKE_CASE						     =   7
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   False
      __SCREAMING_SNAKE_CASE						     =   False
      __SCREAMING_SNAKE_CASE						     =   False
      __SCREAMING_SNAKE_CASE						     =   2
      __SCREAMING_SNAKE_CASE						     =   99
      __SCREAMING_SNAKE_CASE						     =   0
      __SCREAMING_SNAKE_CASE						     =   32
      __SCREAMING_SNAKE_CASE						     =   2
      __SCREAMING_SNAKE_CASE						     =   4
      __SCREAMING_SNAKE_CASE						     =   0.1
      __SCREAMING_SNAKE_CASE						     =   0.1
      __SCREAMING_SNAKE_CASE						     =   512
      __SCREAMING_SNAKE_CASE						     =   16
      __SCREAMING_SNAKE_CASE						     =   2
      __SCREAMING_SNAKE_CASE						     =   0.02
      __SCREAMING_SNAKE_CASE						     =   3
      __SCREAMING_SNAKE_CASE						     =   4
      __SCREAMING_SNAKE_CASE						     =   """last"""
      __SCREAMING_SNAKE_CASE						     =   True
      __SCREAMING_SNAKE_CASE						     =   None
      __SCREAMING_SNAKE_CASE						     =   0
 def    UpperCAmelCase__	(	self      : List[str]    )						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size    )
      __SCREAMING_SNAKE_CASE						     =   random_attention_mask([self.batch_size, self.seq_length]      ,							dtype=tf.floataa    )

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

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

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

      __SCREAMING_SNAKE_CASE						     =   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      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : int      ,							__SCREAMING_SNAKE_CASE      : List[Any]      ,							__SCREAMING_SNAKE_CASE      : int      ,							__SCREAMING_SNAKE_CASE      : Dict      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : List[str]      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : List[str]      ,							__SCREAMING_SNAKE_CASE      : int      ,							)						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMModel(config=__SCREAMING_SNAKE_CASE    )
      __SCREAMING_SNAKE_CASE						     =   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
      __SCREAMING_SNAKE_CASE						     =   model(__SCREAMING_SNAKE_CASE    )

      __SCREAMING_SNAKE_CASE						     =   [input_ids, input_mask]
      __SCREAMING_SNAKE_CASE						     =   model(__SCREAMING_SNAKE_CASE    )
      self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.seq_length, self.hidden_size)    )
 def    UpperCAmelCase__	(	self      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Any      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : str      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : List[str]      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : Any      ,							)						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMWithLMHeadModel(__SCREAMING_SNAKE_CASE    )

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

      __SCREAMING_SNAKE_CASE						     =   outputs

      self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.vocab_size)    )
 def    UpperCAmelCase__	(	self      : int      ,							__SCREAMING_SNAKE_CASE      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : Any      ,							__SCREAMING_SNAKE_CASE      : Dict      ,							__SCREAMING_SNAKE_CASE      : str      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Dict      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]      ,							)						->				List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMForQuestionAnsweringSimple(__SCREAMING_SNAKE_CASE    )

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

      __SCREAMING_SNAKE_CASE						     =   model(__SCREAMING_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      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : str      ,							__SCREAMING_SNAKE_CASE      : List[Any]      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : List[str]      ,							__SCREAMING_SNAKE_CASE      : Optional[int]      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							)						->				Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMForSequenceClassification(__SCREAMING_SNAKE_CASE    )

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

      __SCREAMING_SNAKE_CASE						     =   model(__SCREAMING_SNAKE_CASE    )

      self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.type_sequence_label_size)    )
 def    UpperCAmelCase__	(	self      : Optional[Any]      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : int      ,							__SCREAMING_SNAKE_CASE      : str      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Any      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							)						->				str:


      """simple docstring"""




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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.num_choices
      __SCREAMING_SNAKE_CASE						     =   TFXLMForMultipleChoice(config=__SCREAMING_SNAKE_CASE    )
      __SCREAMING_SNAKE_CASE						     =   tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE      ,							1    )      ,							(1, self.num_choices, 1)    )
      __SCREAMING_SNAKE_CASE						     =   tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE      ,							1    )      ,							(1, self.num_choices, 1)    )
      __SCREAMING_SNAKE_CASE						     =   tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE      ,							1    )      ,							(1, self.num_choices, 1)    )
      __SCREAMING_SNAKE_CASE						     =   {
          """input_ids""": multiple_choice_inputs_ids,
          """attention_mask""": multiple_choice_input_mask,
          """token_type_ids""": multiple_choice_token_type_ids,
      }
      __SCREAMING_SNAKE_CASE						     =   model(__SCREAMING_SNAKE_CASE    )
      self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_choices)    )


 def    UpperCAmelCase__	(	self      : Dict    )						->				Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   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    
      )     ,        
      )						     =   config_and_inputs
      __SCREAMING_SNAKE_CASE						     =   {
          """input_ids""": input_ids,
          """token_type_ids""": token_type_ids,
          """langs""": token_type_ids,
          """lengths""": input_lengths,
      }
      return config, inputs_dict







@require_tf
class 		lowerCAmelCase__     (   a				,      a				,      unittest.TestCase      ):



 """simple docstring"""



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


      """simple docstring"""




      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      : int    )						->				Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMModelTester(self    )
      __SCREAMING_SNAKE_CASE						     =   ConfigTester(self      ,							config_class=__SCREAMING_SNAKE_CASE      ,							emb_dim=37    )
 def    UpperCAmelCase__	(	self      : str    )						->				Union[str, Any]:


      """simple docstring"""




      self.config_tester.run_common_tests()
 def    UpperCAmelCase__	(	self      : Optional[Any]    )						->				int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_model(*__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : int    )						->				Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_lm_head(*__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : Optional[int]    )						->				Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_qa(*__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : Optional[Any]    )						->				List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_sequence_classif(*__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : List[str]    )						->				Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_for_token_classification(*__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : int    )						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_for_multiple_choice(*__SCREAMING_SNAKE_CASE    )


 @slow
 def    UpperCAmelCase__	(	self      : Optional[Any]    )						->				List[Any]:


      """simple docstring"""




      for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __SCREAMING_SNAKE_CASE						     =   TFXLMModel.from_pretrained(__SCREAMING_SNAKE_CASE    )
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE    )







@require_tf
class 		lowerCAmelCase__     (   unittest.TestCase      ):



 """simple docstring"""



 @slow
 def    UpperCAmelCase__	(	self      : Union[str, Any]    )						->				List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""    )
      __SCREAMING_SNAKE_CASE						     =   tf.convert_to_tensor([[14, 447]]      ,							dtype=tf.intaa    )  # the president
      __SCREAMING_SNAKE_CASE						     =   [
          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						     =   model.generate(__SCREAMING_SNAKE_CASE      ,							do_sample=__SCREAMING_SNAKE_CASE    )
      self.assertListEqual(output_ids[0].numpy().tolist()      ,							__SCREAMING_SNAKE_CASE    )









'''simple docstring'''



from __future__ import annotations

from collections.abc import Callable







def      a__ (						a__   ,					a__   ,					a__   ,					a__ = 1_00   ,					):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE						     =   x_start
     __SCREAMING_SNAKE_CASE						     =   fnc(a__		)
     __SCREAMING_SNAKE_CASE						     =   0.0

     for _ in range(a__		):
          # Approximates small segments of curve as linear and solve
          # for trapezoidal area
          __SCREAMING_SNAKE_CASE						     =   (x_end - x_start) / steps + xa
          __SCREAMING_SNAKE_CASE						     =   fnc(a__		)
          area += abs(fxa + fxa		) * (xa - xa) / 2

          # Increment step
          __SCREAMING_SNAKE_CASE						     =   xa
          __SCREAMING_SNAKE_CASE						     =   fxa
     return area


if __name__ == "__main__":







  def      a__ (						a__		):




       """simple docstring"""


       return x**3

  print('f(x) = x^3')
  print('The area between the curve, x = -10, x = 10 and the x axis is:')
  UpperCAmelCase				: Optional[Any]         =  1_0
  while i <= 1_0_0_0_0_0:
    UpperCAmelCase				: Union[str, Any]         =  trapezoidal_area(f, -5, 5, i)
    print(f"""with {i} steps: {area}""")
    i *= 1_0






