


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





						"""simple docstring"""




						def __init__( self				:					List[str]	,				_lowerCamelCase				:					Optional[int]	,				)							->					List[Any]:
										__magic_name__	  = parent
										__magic_name__	  = 13
										__magic_name__	  = 7
										__magic_name__	  = True
										__magic_name__	  = True
										__magic_name__	  = True
										__magic_name__	  = True
										__magic_name__	  = True
										__magic_name__	  = False
										__magic_name__	  = False
										__magic_name__	  = False
										__magic_name__	  = 2
										__magic_name__	  = 99
										__magic_name__	  = 0
										__magic_name__	  = 32
										__magic_name__	  = 2
										__magic_name__	  = 4
										__magic_name__	  = 0.1
										__magic_name__	  = 0.1
										__magic_name__	  = 5_12
										__magic_name__	  = 16
										__magic_name__	  = 2
										__magic_name__	  = 0.02
										__magic_name__	  = 3
										__magic_name__	  = 4
										__magic_name__	  = "last"
										__magic_name__	  = True
										__magic_name__	  = None
										__magic_name__	  = 0
						def 					__A					( self				:					Tuple  )							->					Optional[int]:
										__magic_name__	  = ids_tensor([self.batch_size, self.seq_length]	,				self.vocab_size  )
										__magic_name__	  = random_attention_mask([self.batch_size, self.seq_length]	,				dtype=tf.floataa  )

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

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

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

										__magic_name__	  = 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				:					Optional[int]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					Tuple	,				_lowerCamelCase				:					Any	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Dict	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					Optional[int]	,				)							->					List[str]:
										__magic_name__	  = TFXLMModel(config=_lowerCamelCase  )
										__magic_name__	  = {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
										__magic_name__	  = model(_lowerCamelCase  )

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

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

										__magic_name__	  = outputs

										self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.seq_length, self.vocab_size)  )
						def 					__A					( self				:					List[str]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					List[Any]	,				_lowerCamelCase				:					Dict	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Optional[Any]	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					List[Any]	,				_lowerCamelCase				:					Optional[int]	,				)							->					Optional[int]:
										__magic_name__	  = TFXLMForQuestionAnsweringSimple(_lowerCamelCase  )

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

										__magic_name__	  = 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 					__A					( self				:					Union[str, Any]	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Any	,				_lowerCamelCase				:					Optional[Any]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Optional[Any]	,				_lowerCamelCase				:					Tuple	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Optional[Any]	,				_lowerCamelCase				:					Tuple	,				)							->					str:
										__magic_name__	  = TFXLMForSequenceClassification(_lowerCamelCase  )

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

										__magic_name__	  = model(_lowerCamelCase  )

										self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.type_sequence_label_size)  )
						def 					__A					( self				:					Dict	,				_lowerCamelCase				:					int	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					List[Any]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Any	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Tuple	,				_lowerCamelCase				:					Optional[int]	,				)							->					Optional[Any]:
										__magic_name__	  = self.num_labels
										__magic_name__	  = TFXLMForTokenClassification(config=_lowerCamelCase  )
										__magic_name__	  = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										__magic_name__	  = model(_lowerCamelCase  )
										self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.seq_length, self.num_labels)  )
						def 					__A					( self				:					Optional[Any]	,				_lowerCamelCase				:					int	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Optional[int]	,				_lowerCamelCase				:					Tuple	,				_lowerCamelCase				:					List[Any]	,				_lowerCamelCase				:					int	,				_lowerCamelCase				:					Tuple	,				_lowerCamelCase				:					List[str]	,				)							->					Union[str, Any]:
										__magic_name__	  = self.num_choices
										__magic_name__	  = TFXLMForMultipleChoice(config=_lowerCamelCase  )
										__magic_name__	  = tf.tile(tf.expand_dims(_lowerCamelCase	,				1  )	,				(1, self.num_choices, 1)  )
										__magic_name__	  = tf.tile(tf.expand_dims(_lowerCamelCase	,				1  )	,				(1, self.num_choices, 1)  )
										__magic_name__	  = tf.tile(tf.expand_dims(_lowerCamelCase	,				1  )	,				(1, self.num_choices, 1)  )
										__magic_name__	  = {
										    "input_ids": multiple_choice_inputs_ids,
										    "attention_mask": multiple_choice_input_mask,
										    "token_type_ids": multiple_choice_token_type_ids,
										}
										__magic_name__	  = model(_lowerCamelCase  )
										self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_choices)  )

						def 					__A					( self				:					int  )							->					Dict:
										__magic_name__	  = self.prepare_config_and_inputs()
										(
										    (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      (
										    __magic_name__
										)  ,      
										)	  = config_and_inputs
										__magic_name__	  = {
										    "input_ids": input_ids,
										    "token_type_ids": token_type_ids,
										    "langs": token_type_ids,
										    "lengths": input_lengths,
										}
										return config, inputs_dict






@require_tf
class 		UpperCamelCase_		(					A   ,		A   ,		unittest.TestCase   ):





						"""simple docstring"""




						UpperCAmelCase__	:       Tuple         =     (
						    (
						        TFXLMModel,
						        TFXLMWithLMHeadModel,
						        TFXLMForSequenceClassification,
						        TFXLMForQuestionAnsweringSimple,
						        TFXLMForTokenClassification,
						        TFXLMForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						UpperCAmelCase__	:       List[str]         =     (
						    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Check other models whether language generation is also applicable
						UpperCAmelCase__	:       int         =     (
						    {
						        '''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__	:       Tuple         =     False
						UpperCAmelCase__	:       Optional[int]         =     False
						def 					__A					( self				:					List[Any]	,				_lowerCamelCase				:					str	,				_lowerCamelCase				:					str	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					List[str]	,				_lowerCamelCase				:					Any  )							->					List[Any]:
										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				:					Tuple  )							->					Optional[Any]:
										__magic_name__	  = TFXLMModelTester(self  )
										__magic_name__	  = ConfigTester(self	,				config_class=_lowerCamelCase	,				emb_dim=37  )
						def 					__A					( self				:					Any  )							->					Optional[Any]:
										self.config_tester.run_common_tests()
						def 					__A					( self				:					Dict  )							->					List[Any]:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_model(*_lowerCamelCase  )
						def 					__A					( self				:					List[str]  )							->					Tuple:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_lm_head(*_lowerCamelCase  )
						def 					__A					( self				:					Dict  )							->					List[Any]:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_qa(*_lowerCamelCase  )
						def 					__A					( self				:					str  )							->					Optional[Any]:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_sequence_classif(*_lowerCamelCase  )
						def 					__A					( self				:					List[Any]  )							->					Tuple:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_token_classification(*_lowerCamelCase  )
						def 					__A					( self				:					List[str]  )							->					int:
										__magic_name__	  = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowerCamelCase  )

						@slow
						def 					__A					( self				:					int  )							->					Optional[Any]:
										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														__magic_name__	  = TFXLMModel.from_pretrained(_lowerCamelCase  )
														self.assertIsNotNone(_lowerCamelCase  )






@require_tf
class 		UpperCamelCase_		(					unittest.TestCase   ):





						"""simple docstring"""




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







'''simple docstring'''
import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


__magic_name__   :   int  							=logging.get_logger(__name__)






class 		UpperCamelCase_		(					A   ):





						"""simple docstring"""




						def __init__( self				:					List[str]	,				*_lowerCamelCase				:					List[str]	,				**_lowerCamelCase				:					Optional[Any]  )							->					None:
										warnings.warn(
										    "The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers."
										    " Please use ConvNextImageProcessor instead."	,				_lowerCamelCase	,				)
										super().__init__(*_lowerCamelCase	,				**_lowerCamelCase  )



