"""simple docstring"""






from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import (
           TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFTransfoXLForSequenceClassification,
           TFTransfoXLLMHeadModel,
           TFTransfoXLModel,
       )





class  _A						:

      def __init__(						self		,       __lowerCAmelCase		,       ):







            """simple docstring"""



            lowercase														=	parent
            lowercase														=	13
            lowercase														=	7
            lowercase														=	30
            lowercase														=	self.seq_length + self.mem_len
            lowercase														=	15
            lowercase														=	True
            lowercase														=	True
            lowercase														=	99
            lowercase														=	[10, 50, 80]
            lowercase														=	32
            lowercase														=	32
            lowercase														=	4
            lowercase														=	8
            lowercase														=	128
            lowercase														=	2
            lowercase														=	2
            lowercase														=	None
            lowercase														=	1
            lowercase														=	0
            lowercase														=	3
            lowercase														=	self.vocab_size - 1
            lowercase														=	0.0_1

      def 				A__       (						self						):







            """simple docstring"""



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

            lowercase														=	None
            if self.use_labels:
                  lowercase														=	ids_tensor([self.batch_size, self.seq_length]		,       self.vocab_size						)

            lowercase														=	TransfoXLConfig(
                vocab_size=self.vocab_size		,       mem_len=self.mem_len		,       clamp_len=self.clamp_len		,       cutoffs=self.cutoffs		,       d_model=self.hidden_size		,       d_embed=self.d_embed		,       n_head=self.num_attention_heads		,       d_head=self.d_head		,       d_inner=self.d_inner		,       div_val=self.div_val		,       n_layer=self.num_hidden_layers		,       eos_token_id=self.eos_token_id		,       pad_token_id=self.vocab_size - 1		,       init_range=self.init_range		,       num_labels=self.num_labels		,       )

            return (config, input_ids_a, input_ids_a, lm_labels)

      def 				A__       (						self						):







            """simple docstring"""



            random.seed(self.seed						)
            tf.random.set_seed(self.seed						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	TFTransfoXLModel(__lowerCAmelCase						)

            lowercase														=	model(__lowerCAmelCase						).to_tuple()

            lowercase														=	{'''input_ids''': input_ids_a, '''mems''': mems_a}

            lowercase														=	model(__lowerCAmelCase						).to_tuple()

            self.parent.assertEqual(hidden_states_a.shape		,       (self.batch_size, self.seq_length, self.hidden_size)						)
            self.parent.assertEqual(hidden_states_a.shape		,       (self.batch_size, self.seq_length, self.hidden_size)						)
            self.parent.assertListEqual(
                [mem.shape for mem in mems_a]		,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,       )
            self.parent.assertListEqual(
                [mem.shape for mem in mems_a]		,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,       )

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	TFTransfoXLLMHeadModel(__lowerCAmelCase						)

            lowercase														=	model(__lowerCAmelCase						).to_tuple()

            lowercase														=	{'''input_ids''': input_ids_a, '''labels''': lm_labels}
            lowercase														=	model(__lowerCAmelCase						).to_tuple()

            lowercase														=	model([input_ids_a, mems_a]						).to_tuple()

            lowercase														=	{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

            lowercase														=	model(__lowerCAmelCase						).to_tuple()

            self.parent.assertEqual(lm_logits_a.shape		,       (self.batch_size, self.seq_length, self.vocab_size)						)
            self.parent.assertListEqual(
                [mem.shape for mem in mems_a]		,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,       )

            self.parent.assertEqual(lm_logits_a.shape		,       (self.batch_size, self.seq_length, self.vocab_size)						)
            self.parent.assertListEqual(
                [mem.shape for mem in mems_a]		,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,       )

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	TFTransfoXLForSequenceClassification(__lowerCAmelCase						)
            lowercase														=	model(__lowerCAmelCase						)
            self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.num_labels)						)







      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.prepare_config_and_inputs()
            (lowercase)														=	config_and_inputs
            lowercase														=	{'''input_ids''': input_ids_a}
            return config, inputs_dict






@require_tf
class  _A						(       lowerCAmelCase_  ,    lowerCAmelCase_  ,    unittest.TestCase	):
      snake_case__			:   Union[str, Any]							  =	(
          (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
      )
      snake_case__			:   int							  =	() if is_tf_available() else ()
      snake_case__			:   Dict							  =	(
          {
              'feature-extraction': TFTransfoXLModel,
              'text-classification': TFTransfoXLForSequenceClassification,
              'text-generation': TFTransfoXLLMHeadModel,
              'zero-shot': TFTransfoXLForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
      snake_case__			:   List[str]							  =	False
      snake_case__			:   List[str]							  =	False
      snake_case__			:   List[Any]							  =	False
      snake_case__			:   List[str]							  =	False

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            if pipeline_test_casse_name == "TextGenerationPipelineTests":
                  # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
                  # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
                  # tokenizer.
                  return True

            return False

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	TFTransfoXLModelTester(self						)
            lowercase														=	ConfigTester(self		,       config_class=__lowerCAmelCase		,       d_embed=37						)

      def 				A__       (						self						):







            """simple docstring"""



            self.config_tester.run_common_tests()

      def 				A__       (						self						):







            """simple docstring"""



            self.model_tester.set_seed()
            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_transfo_xl_model(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            self.model_tester.set_seed()
            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_transfo_xl_lm_head(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	self.model_tester.prepare_config_and_inputs_for_common()
            lowercase														=	[TFTransfoXLForSequenceClassification]

            for model_class in self.all_model_classes:
                  lowercase														=	model_class(__lowerCAmelCase						)
                  assert isinstance(model.get_input_embeddings()		,       tf.keras.layers.Layer						)
                  if model_class in list_other_models_with_output_ebd:
                        lowercase														=	model.get_output_embeddings()
                        assert isinstance(__lowerCAmelCase		,       tf.keras.layers.Layer						)
                        lowercase														=	model.get_bias()
                        assert name is None
                  else:
                        lowercase														=	model.get_output_embeddings()
                        assert x is None
                        lowercase														=	model.get_bias()
                        assert name is None

      def 				A__       (						self						):







            """simple docstring"""



            pass

      @slow
      def 				A__       (						self						):







            """simple docstring"""



            for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase														=	TFTransfoXLModel.from_pretrained(__lowerCAmelCase						)
                  self.assertIsNotNone(__lowerCAmelCase						)







      @unittest.skip(reason="""This model doesn\'t play well with fit() due to not returning a single loss."""						)
      def 				A__       (						self						):







            """simple docstring"""



            pass






@require_tf
class  _A						(       unittest.TestCase	):

      @unittest.skip("""Skip test until #12651 is resolved."""						)
      @slow
      def 				A__       (						self						):







            """simple docstring"""



            lowercase														=	TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""						)
            # fmt: off
            lowercase														=	tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]]		,       dtype=tf.intaa						)  # noqa: E231
            # fmt: on
            #  In 1991 , the remains of Russian Tsar Nicholas II and his family
            #  ( except for Alexei and Maria ) are discovered .
            #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
            #  remainder of the story . 1883 Western Siberia ,
            #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
            #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
            #  father initially slaps him for making such an accusation , Rasputin watches as the
            #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
            #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
            #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

            # fmt: off
            lowercase														=	[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
            # fmt: on
            #  In 1991, the remains of Russian Tsar Nicholas II and his family (
            #  except for Alexei and Maria ) are discovered. The voice of young son,
            #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
            #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
            #  and a group of men to perform magic. Rasputin has a vision and
            #  denounces one of the men as a horse thief. Although his father initially
            #  slaps him for making such an accusation, Rasputin watches as the man
            #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
            #  of the Virgin Mary, prompting him to become a priest.
            #  Rasputin quickly becomes famous, with people, even a bishop, begging for
            #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
            # Nicholas II and his family were discovered. The voice of <unk> young son,
            # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

            lowercase														=	model.generate(__lowerCAmelCase		,       max_length=200		,       do_sample=__lowerCAmelCase						)
            self.assertListEqual(output_ids[0].numpy().tolist()		,       __lowerCAmelCase						)








"""simple docstring"""






from pathlib import Path
from typing import List

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image


_lowercase : Union[str, Any]      						=						["text", "image", "audio"]






def      snake_case__   (		__lowerCamelCase				:    List[str]	):
			"""simple docstring"""
			lowerCamelCase__		:		Union[str, Any]			=[]

			for input_type in input_types:
						if input_type == "text":
									inputs.append('''Text input'''	)
						elif input_type == "image":
									inputs.append(
									    Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''	)	) / '''000000039769.png'''	).resize((512, 512)	)	)
						elif input_type == "audio":
									inputs.append(torch.ones(3000	)	)
						elif isinstance(__lowerCamelCase							,		__lowerCamelCase	):
									inputs.append(create_inputs(__lowerCamelCase	)	)
						else:
									raise ValueError(f'''Invalid type requested: {input_type}'''	)

			return inputs






def      snake_case__   (		__lowerCamelCase				:    List	):
			"""simple docstring"""
			lowerCamelCase__		:		Tuple			=[]

			for output in outputs:
						if isinstance(__lowerCamelCase							,		(str, AgentText)	):
									output_types.append('''text'''	)
						elif isinstance(__lowerCamelCase							,		(Image.Image, AgentImage)	):
									output_types.append('''image'''	)
						elif isinstance(__lowerCamelCase							,		(torch.Tensor, AgentAudio)	):
									output_types.append('''audio'''	)
						else:
									raise ValueError(f'''Invalid output: {output}'''	)

			return output_types

@is_tool_test
class        __SCREAMING_SNAKE_CASE	:


					'''simple docstring'''





					def 		snake_case       (       self							:  Any     )->					Optional[Any]:
								self.assertTrue(hasattr(self.tool,  '''inputs'''     )     )
								self.assertTrue(hasattr(self.tool,  '''outputs'''     )     )

								lowerCamelCase__		:		Tuple			=self.tool.inputs
								for _input in inputs:
											if isinstance(_input,  lowerCamelCase     ):
														for __input in _input:
																	self.assertTrue(__input in authorized_types     )
											else:
														self.assertTrue(_input in authorized_types     )

								lowerCamelCase__		:		Optional[Any]			=self.tool.outputs
								for _output in outputs:
											self.assertTrue(_output in authorized_types     )



					def 		snake_case       (       self							:  Optional[int]     )->					Union[str, Any]:
								lowerCamelCase__		:		Optional[int]			=create_inputs(self.tool.inputs     )
								lowerCamelCase__		:		List[Any]			=self.tool(*lowerCamelCase     )

								# There is a single output
								if len(self.tool.outputs     ) == 1:
											lowerCamelCase__		:		Optional[int]			=[outputs]

								self.assertListEqual(output_types(lowerCamelCase     ),  self.tool.outputs     )



					def 		snake_case       (       self							:  Union[str, Any]     )->					List[str]:
								self.assertTrue(hasattr(self.tool,  '''description'''     )     )
								self.assertTrue(hasattr(self.tool,  '''default_checkpoint'''     )     )
								self.assertTrue(self.tool.description.startswith('''This is a tool that'''     )     )



					def 		snake_case       (       self							:  Union[str, Any]     )->					str:
								lowerCamelCase__		:		List[str]			=create_inputs(self.tool.inputs     )
								lowerCamelCase__		:		Optional[Any]			=self.tool(*lowerCamelCase     )

								if not isinstance(lowerCamelCase,  lowerCamelCase     ):
											lowerCamelCase__		:		Any			=[outputs]

								self.assertEqual(len(lowerCamelCase     ),  len(self.tool.outputs     )     )

								for output, output_type in zip(lowerCamelCase,  self.tool.outputs     ):
											lowerCamelCase__		:		List[Any]			=AGENT_TYPE_MAPPING[output_type]
											self.assertTrue(isinstance(lowerCamelCase,  lowerCamelCase     )     )




					def 		snake_case       (       self							:  Optional[Any]     )->					List[Any]:
								lowerCamelCase__		:		Optional[Any]			=create_inputs(self.tool.inputs     )

								lowerCamelCase__		:		List[str]			=[]

								for _input, input_type in zip(lowerCamelCase,  self.tool.inputs     ):
											if isinstance(lowerCamelCase,  lowerCamelCase     ):
														_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input     ) for _input_type in input_type]     )
											else:
														_inputs.append(AGENT_TYPE_MAPPING[input_type](_input     )     )

        # Should not raise an error
								lowerCamelCase__		:		Any			=self.tool(*lowerCamelCase     )

								if not isinstance(lowerCamelCase,  lowerCamelCase     ):
											lowerCamelCase__		:		Optional[int]			=[outputs]

								self.assertEqual(len(lowerCamelCase     ),  len(self.tool.outputs     )     )




