





import unittest

from datasets import load_dataset

from transformers import load_tool

from .test_tools_common import ToolTesterMixin





class 	lowerCAmelCase__(       unittest.TestCase     ,   __lowercase			):






       '''simple docstring'''


       def 			UpperCamelCase_	(					self							)	->   Tuple:
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							load_tool("document-question-answering"							)
            self.tool.setup()
            _SCREAMING_SNAKE_CASE				:		Dict  			=							load_tool("document-question-answering"			,  remote=__lowerCamelCase							)




       def 			UpperCamelCase_	(					self							)	->   Any:
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							load_dataset("hf-internal-testing/example-documents"			,  split="test"							)
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							dataset[0]["image"]

            _SCREAMING_SNAKE_CASE				:		Tuple  			=							self.tool(__lowerCamelCase			,  "When is the coffee break?"							)
            self.assertEqual(__lowerCamelCase			,  "11-14 to 11:39 a.m."							)




       def 			UpperCamelCase_	(					self							)	->   Any:
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							load_dataset("hf-internal-testing/example-documents"			,  split="test"							)
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							dataset[0]["image"]

            _SCREAMING_SNAKE_CASE				:		Tuple  			=							self.remote_tool(__lowerCamelCase			,  "When is the coffee break?"							)
            self.assertEqual(__lowerCamelCase			,  "11-14 to 11:39 a.m."							)




       def 			UpperCamelCase_	(					self							)	->   Dict:
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							load_dataset("hf-internal-testing/example-documents"			,  split="test"							)
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							dataset[0]["image"]

            self.tool(document=__lowerCamelCase			,  question="When is the coffee break?"							)







       def 			UpperCamelCase_	(					self							)	->   Optional[Any]:
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							load_dataset("hf-internal-testing/example-documents"			,  split="test"							)
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							dataset[0]["image"]

            _SCREAMING_SNAKE_CASE				:		Any  			=							self.remote_tool(document=__lowerCamelCase			,  question="When is the coffee break?"							)
            self.assertEqual(__lowerCamelCase			,  "11-14 to 11:39 a.m."							)





'''simple docstring'''



from __future__ import annotations

import unittest

from transformers import CTRLConfig, 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.models.ctrl.modeling_tf_ctrl import (
         TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFCTRLForSequenceClassification,
         TFCTRLLMHeadModel,
         TFCTRLModel,
     )





class 			lowerCAmelCase      (       __lowerCAmelCase):


       def __init__(      self			,     __SCREAMING_SNAKE_CASE			,     )					->     Any:



            '''simple docstring'''




            __snake_case			    =     parent
            __snake_case			    =     13
            __snake_case			    =     7
            __snake_case			    =     True
            __snake_case			    =     True
            __snake_case			    =     True
            __snake_case			    =     True
            __snake_case			    =     True
            __snake_case			    =     99
            __snake_case			    =     32
            __snake_case			    =     2
            __snake_case			    =     4
            __snake_case			    =     37
            __snake_case			    =     '''gelu'''
            __snake_case			    =     0.1
            __snake_case			    =     0.1
            __snake_case			    =     512
            __snake_case			    =     16
            __snake_case			    =     2
            __snake_case			    =     0.02
            __snake_case			    =     3
            __snake_case			    =     4
            __snake_case			    =     None
            __snake_case			    =     self.vocab_size - 1


       def 					lowerCAmelCase					(      self     )					->     Any:



            '''simple docstring'''




            __snake_case			    =     ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size     )

            __snake_case			    =     None
            if self.use_input_mask:
                 __snake_case			    =     random_attention_mask([self.batch_size, self.seq_length]     )

            __snake_case			    =     None
            if self.use_token_type_ids:
                 __snake_case			    =     ids_tensor([self.batch_size, self.seq_length]			,     self.type_vocab_size     )

            __snake_case			    =     None
            if self.use_mc_token_ids:
                 __snake_case			    =     ids_tensor([self.batch_size, self.num_choices]			,     self.seq_length     )

            __snake_case			    =     None
            __snake_case			    =     None
            __snake_case			    =     None
            if self.use_labels:
                 __snake_case			    =     ids_tensor([self.batch_size]			,     self.type_sequence_label_size     )
                 __snake_case			    =     ids_tensor([self.batch_size, self.seq_length]			,     self.num_labels     )
                 __snake_case			    =     ids_tensor([self.batch_size]			,     self.num_choices     )

            __snake_case			    =     CTRLConfig(
                vocab_size=self.vocab_size			,     n_embd=self.hidden_size			,     n_layer=self.num_hidden_layers			,     n_head=self.num_attention_heads			,     n_positions=self.max_position_embeddings			,     pad_token_id=self.pad_token_id			,     )

            __snake_case			    =     ids_tensor([self.num_hidden_layers, self.num_attention_heads]			,     2     )

            return (
                config,
                input_ids,
                input_mask,
                head_mask,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     *__SCREAMING_SNAKE_CASE     )					->     List[Any]:



            '''simple docstring'''




            __snake_case			    =     TFCTRLModel(config=__SCREAMING_SNAKE_CASE     )
            __snake_case			    =     {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )

            __snake_case			    =     [input_ids, None, input_mask]  # None is the input for 'past'
            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )

            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )

            self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)     )


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     *__SCREAMING_SNAKE_CASE     )					->     int:



            '''simple docstring'''




            __snake_case			    =     TFCTRLLMHeadModel(config=__SCREAMING_SNAKE_CASE     )
            __snake_case			    =     {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )
            self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)     )


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     *__SCREAMING_SNAKE_CASE     )					->     List[str]:



            '''simple docstring'''




            __snake_case			    =     self.num_labels
            __snake_case			    =     ids_tensor([self.batch_size]			,     self.type_sequence_label_size     )
            __snake_case			    =     {
                '''input_ids''': input_ids,
                '''token_type_ids''': token_type_ids,
                '''labels''': sequence_labels,
            }
            __snake_case			    =     TFCTRLForSequenceClassification(__SCREAMING_SNAKE_CASE     )
            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )
            self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)     )




       def 					lowerCAmelCase					(      self     )					->     Optional[Any]:



            '''simple docstring'''




            __snake_case			    =     self.prepare_config_and_inputs()

            (
                (
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			(
                __snake_case
            )    ,			
            )			    =     config_and_inputs

            __snake_case			    =     {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
            return config, inputs_dict





@require_tf
class 			lowerCAmelCase      (       __lowerCAmelCase ,      __lowerCAmelCase ,      unittest.TestCase):
       __lowercase     :					str       				=	(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
       __lowercase     :					Tuple       				=	(TFCTRLLMHeadModel,) if is_tf_available() else ()
       __lowercase     :					Optional[Any]       				=	(
           {
               '''feature-extraction''': TFCTRLModel,
               '''text-classification''': TFCTRLForSequenceClassification,
               '''text-generation''': TFCTRLLMHeadModel,
               '''zero-shot''': TFCTRLForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase     :					List[Any]       				=	False
       __lowercase     :					Optional[int]       				=	False


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )					->     Dict:



            '''simple docstring'''




            if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                 # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                 # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
                 # config could not be created.
                 return True

            return False


       def 					lowerCAmelCase					(      self     )					->     Optional[int]:



            '''simple docstring'''




            __snake_case			    =     TFCTRLModelTester(self     )
            __snake_case			    =     ConfigTester(self			,     config_class=__SCREAMING_SNAKE_CASE			,     n_embd=37     )


       def 					lowerCAmelCase					(      self     )					->     Dict:



            '''simple docstring'''




            self.config_tester.run_common_tests()


       def 					lowerCAmelCase					(      self     )					->     Union[str, Any]:



            '''simple docstring'''




            __snake_case			    =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_model(*__SCREAMING_SNAKE_CASE     )


       def 					lowerCAmelCase					(      self     )					->     Optional[int]:



            '''simple docstring'''




            __snake_case			    =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_lm_head(*__SCREAMING_SNAKE_CASE     )


       def 					lowerCAmelCase					(      self     )					->     List[str]:



            '''simple docstring'''




            __snake_case			    =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_for_sequence_classification(*__SCREAMING_SNAKE_CASE     )


       def 					lowerCAmelCase					(      self     )					->     Optional[int]:



            '''simple docstring'''




            __snake_case    ,			__snake_case			    =     self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case			    =     [TFCTRLLMHeadModel]
            __snake_case			    =     [TFCTRLForSequenceClassification]

            for model_class in self.all_model_classes:
                 __snake_case			    =     model_class(__SCREAMING_SNAKE_CASE     )
                 model.build()  # may be needed for the get_bias() call below
                 assert isinstance(model.get_input_embeddings()			,     tf.keras.layers.Layer     )

                 if model_class in list_lm_models:
                      __snake_case			    =     model.get_output_embeddings()
                      assert isinstance(__SCREAMING_SNAKE_CASE			,     tf.keras.layers.Layer     )
                      __snake_case			    =     model.get_bias()
                      assert isinstance(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )
                      for k, v in name.items():
                           assert isinstance(__SCREAMING_SNAKE_CASE			,     tf.Variable     )
                 elif model_class in list_other_models_with_output_ebd:
                      __snake_case			    =     model.get_output_embeddings()
                      assert isinstance(__SCREAMING_SNAKE_CASE			,     tf.keras.layers.Layer     )
                      __snake_case			    =     model.get_bias()
                      assert name is None
                 else:
                      __snake_case			    =     model.get_output_embeddings()
                      assert x is None
                      __snake_case			    =     model.get_bias()
                      assert name is None




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



            '''simple docstring'''




            for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case			    =     TFCTRLModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
                 self.assertIsNotNone(__SCREAMING_SNAKE_CASE     )





@require_tf
class 			lowerCAmelCase      (       unittest.TestCase):


       @slow
       def 					lowerCAmelCase					(      self     )					->     Tuple:



            '''simple docstring'''




            __snake_case			    =     TFCTRLLMHeadModel.from_pretrained('''ctrl'''     )
            __snake_case			    =     tf.convert_to_tensor([[1_1859, 0, 1611, 8]]			,     dtype=tf.intaa     )  # Legal the president is
            __snake_case			    =     [
                1_1859,
                0,
                1611,
                8,
                5,
                150,
                2_6449,
                2,
                19,
                348,
                469,
                3,
                2595,
                48,
                2_0740,
                24_6533,
                24_6533,
                19,
                30,
                5,
            ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

            __snake_case			    =     model.generate(__SCREAMING_SNAKE_CASE			,     do_sample=__SCREAMING_SNAKE_CASE     )
            self.assertListEqual(output_ids[0].numpy().tolist()			,     __SCREAMING_SNAKE_CASE     )






