


from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
						import tensorflow as tf

						from transformers import (
						    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    FlaubertConfig,
						    TFFlaubertForMultipleChoice,
						    TFFlaubertForQuestionAnsweringSimple,
						    TFFlaubertForSequenceClassification,
						    TFFlaubertForTokenClassification,
						    TFFlaubertModel,
						    TFFlaubertWithLMHeadModel,
						)







class 	snake_case_       :
					def __init__(				self       :Optional[Any]      ,__snake_case       :Dict      ,) ->   Optional[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 			lowerCamelCase__(				self       :List[str]				) ->   List[Any]:
												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__					=					FlaubertConfig(
												    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 			lowerCamelCase__(				self       :str      ,__snake_case       :int      ,__snake_case       :List[str]      ,__snake_case       :Tuple      ,__snake_case       :List[str]      ,__snake_case       :Tuple      ,__snake_case       :List[Any]      ,__snake_case       :Dict      ,__snake_case       :int      ,__snake_case       :List[Any]      ,) ->   Union[str, Any]:
												a__					=					TFFlaubertModel(config=__snake_case				)
												a__					=					{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
												a__					=					model(__snake_case				)

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

												a__					=					{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
												a__					=					model(__snake_case				)

												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)				)
					def 			lowerCamelCase__(				self       :List[Any]      ,__snake_case       :str      ,__snake_case       :Union[str, Any]      ,__snake_case       :List[str]      ,__snake_case       :Dict      ,__snake_case       :Optional[int]      ,__snake_case       :int      ,__snake_case       :Any      ,__snake_case       :Optional[Any]      ,__snake_case       :Any      ,) ->   Tuple:
												a__					=					TFFlaubertForQuestionAnsweringSimple(__snake_case				)

												a__					=					{'input_ids': input_ids, 'lengths': input_lengths}

												a__					=					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 			lowerCamelCase__(				self       :int      ,__snake_case       :List[Any]      ,__snake_case       :str      ,__snake_case       :str      ,__snake_case       :Optional[int]      ,__snake_case       :int      ,__snake_case       :int      ,__snake_case       :Union[str, Any]      ,__snake_case       :Optional[int]      ,__snake_case       :str      ,) ->   Any:
												a__					=					TFFlaubertForSequenceClassification(__snake_case				)

												a__					=					{'input_ids': input_ids, 'lengths': input_lengths}

												a__					=					model(__snake_case				)

												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.type_sequence_label_size)				)
					def 			lowerCamelCase__(				self       :Union[str, Any]      ,__snake_case       :Any      ,__snake_case       :Tuple      ,__snake_case       :Dict      ,__snake_case       :List[Any]      ,__snake_case       :Tuple      ,__snake_case       :Any      ,__snake_case       :Optional[int]      ,__snake_case       :Union[str, Any]      ,__snake_case       :List[str]      ,) ->   Optional[Any]:
												a__					=					self.num_labels
												a__					=					TFFlaubertForTokenClassification(config=__snake_case				)
												a__					=					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
												a__					=					model(__snake_case				)
												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.num_labels)				)
					def 			lowerCamelCase__(				self       :Dict      ,__snake_case       :Dict      ,__snake_case       :Optional[Any]      ,__snake_case       :Union[str, Any]      ,__snake_case       :Optional[int]      ,__snake_case       :str      ,__snake_case       :Tuple      ,__snake_case       :str      ,__snake_case       :str      ,__snake_case       :int      ,) ->   int:
												a__					=					self.num_choices
												a__					=					TFFlaubertForMultipleChoice(config=__snake_case				)
												a__					=					tf.tile(tf.expand_dims(__snake_case      ,1				)      ,(1, self.num_choices, 1)				)
												a__					=					tf.tile(tf.expand_dims(__snake_case      ,1				)      ,(1, self.num_choices, 1)				)
												a__					=					tf.tile(tf.expand_dims(__snake_case      ,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(__snake_case				)
												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_choices)				)



					def 			lowerCamelCase__(				self       :int				) ->   Dict:
												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_       (lowerCamelCase_     ,						lowerCamelCase_     ,						unittest.TestCase				):
					UpperCAmelCase__ :   List[Any]   				=      (
					    (
					        TFFlaubertModel,
					        TFFlaubertWithLMHeadModel,
					        TFFlaubertForSequenceClassification,
					        TFFlaubertForQuestionAnsweringSimple,
					        TFFlaubertForTokenClassification,
					        TFFlaubertForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					UpperCAmelCase__ :   List[Any]   				=      (
					    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
					)  # TODO (PVP): Check other models whether language generation is also applicable
					UpperCAmelCase__ :   Any   				=      (
					    {
					        '''feature-extraction''': TFFlaubertModel,
					        '''fill-mask''': TFFlaubertWithLMHeadModel,
					        '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
					        '''text-classification''': TFFlaubertForSequenceClassification,
					        '''token-classification''': TFFlaubertForTokenClassification,
					        '''zero-shot''': TFFlaubertForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					UpperCAmelCase__ :   Optional[int]   				=      False
					UpperCAmelCase__ :   int   				=      False
					def 			lowerCamelCase__(				self       :List[str]      ,__snake_case       :Optional[int]      ,__snake_case       :Optional[Any]      ,__snake_case       :Dict      ,__snake_case       :Optional[int]      ,__snake_case       :Any				) ->   Union[str, 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 			lowerCamelCase__(				self       :Union[str, Any]				) ->   Any:
												a__					=					TFFlaubertModelTester(self				)
												a__					=					ConfigTester(self      ,config_class=__snake_case      ,emb_dim=37				)
					def 			lowerCamelCase__(				self       :Optional[int]				) ->   Tuple:
												self.config_tester.run_common_tests()
					def 			lowerCamelCase__(				self       :Tuple				) ->   Any:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_model(*__snake_case				)
					def 			lowerCamelCase__(				self       :List[str]				) ->   List[str]:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_lm_head(*__snake_case				)
					def 			lowerCamelCase__(				self       :List[str]				) ->   Union[str, Any]:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_qa(*__snake_case				)
					def 			lowerCamelCase__(				self       :Dict				) ->   Optional[Any]:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_sequence_classif(*__snake_case				)
					def 			lowerCamelCase__(				self       :List[str]				) ->   List[str]:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_for_token_classification(*__snake_case				)
					def 			lowerCamelCase__(				self       :List[Any]				) ->   int:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_flaubert_for_multiple_choice(*__snake_case				)



					@slow
					def 			lowerCamelCase__(				self       :List[Any]				) ->   Tuple:
												for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			a__					=					TFFlaubertModel.from_pretrained(__snake_case				)
																			self.assertIsNotNone(__snake_case				)







@require_tf
@require_sentencepiece
@require_tokenizers
class 	snake_case_       (unittest.TestCase				):
					@slow
					def 			lowerCamelCase__(				self       :Union[str, Any]				) ->   List[Any]:
												a__					=					TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'				)

												a__					=					tf.convert_to_tensor(
												    [[0, 1_58, 7_35, 25_92, 14_24, 67_27, 82, 1]]      ,dtype=tf.intaa      ,)  # "J'aime flaubert !"

												a__					=					model(__snake_case				)[0]
												a__					=					tf.TensorShape((1, 8, 5_12)				)
												self.assertEqual(output.shape      ,__snake_case				)
												# compare the actual values for a slice.
												a__					=					tf.convert_to_tensor(
												    [
												        [
												            [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
												            [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
												            [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
												        ]
												    ]      ,dtype=tf.floataa      ,)

												self.assertTrue(np.allclose(output[:, :3, :3].numpy()      ,expected_slice.numpy()      ,atol=1E-4				)				)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case							:	Optional[int]					      =				{
    '''configuration_clipseg''': [
        '''CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPSegConfig''',
        '''CLIPSegTextConfig''',
        '''CLIPSegVisionConfig''',
    ],
    '''processing_clipseg''': ['''CLIPSegProcessor'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							:	List[str]					      =				[
						    '''CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''CLIPSegModel''',
						    '''CLIPSegPreTrainedModel''',
						    '''CLIPSegTextModel''',
						    '''CLIPSegVisionModel''',
						    '''CLIPSegForImageSegmentation''',
						]

if TYPE_CHECKING:
						from .configuration_clipseg import (
						    CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    CLIPSegConfig,
						    CLIPSegTextConfig,
						    CLIPSegVisionConfig,
						)
						from .processing_clipseg import CLIPSegProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_clipseg import (
												    CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
												    CLIPSegForImageSegmentation,
												    CLIPSegModel,
												    CLIPSegPreTrainedModel,
												    CLIPSegTextModel,
												    CLIPSegVisionModel,
												)

else:
						import sys

						snake_case							:	Optional[int]					      =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




