
from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


SCREAMING_SNAKE_CASE__							=    logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE__							=    "ResNetConfig"

# Base docstring
SCREAMING_SNAKE_CASE__							=    "microsoft/resnet-50"
SCREAMING_SNAKE_CASE__							=    [1, 2048, 7, 7]

# Image classification docstring
SCREAMING_SNAKE_CASE__							=    "microsoft/resnet-50"
SCREAMING_SNAKE_CASE__							=    "tiger cat"

SCREAMING_SNAKE_CASE__							=    [
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]
class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       Dict					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int = 3					,			_UpperCAmelCase  :       int = 1					,			_UpperCAmelCase  :       str = "relu"					,			**_UpperCAmelCase  :       Dict    )						->		List[Any]:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= kernel_size // 2
											__lowercase								= tf.keras.layers.ConvaD(
											    UpperCamelCase_					,			kernel_size=UpperCamelCase_					,			strides=UpperCamelCase_					,			padding='valid'					,			use_bias=UpperCamelCase_					,			name='convolution'    )
											# Use same default momentum and epsilon as PyTorch equivalent
											__lowercase								= tf.keras.layers.BatchNormalization(epsilon=1e-5					,			momentum=0.9					,			name='normalization'    )
											__lowercase								= ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'    )





							def       a__			(			self  :       Any					,			_UpperCAmelCase  :       tf.Tensor    )						->		str:



											"""simple docstring"""


											__lowercase								= __lowercase								= (self.pad_value, self.pad_value)
											__lowercase								= tf.pad(UpperCamelCase_					,			[(0, 0), height_pad, width_pad, (0, 0)]    )
											__lowercase								= self.conv(UpperCamelCase_    )
											return hidden_state





							def       a__			(			self  :       Optional[int]					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		List[Any]:



											"""simple docstring"""


											__lowercase								= self.convolution(UpperCamelCase_    )
											__lowercase								= self.normalization(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.activation(UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       int					,			_UpperCAmelCase  :       ResNetConfig					,			**_UpperCAmelCase  :       Tuple    )						->		Any:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= TFResNetConvLayer(
											    config.embedding_size					,			kernel_size=7					,			stride=2					,			activation=config.hidden_act					,			name='embedder'					,			)
											__lowercase								= tf.keras.layers.MaxPoolaD(pool_size=3					,			strides=2					,			padding='valid'					,			name='pooler'    )
											__lowercase								= config.num_channels





							def       a__			(			self  :       Any					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		Any:



											"""simple docstring"""


											__lowercase		, __lowercase		, __lowercase		, __lowercase								= shape_list(UpperCamelCase_    )
											if tf.executing_eagerly() and num_channels != self.num_channels:
															raise ValueError(
															    'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'    )
											__lowercase								= pixel_values
											__lowercase								= self.embedder(UpperCamelCase_    )
											__lowercase								= tf.pad(UpperCamelCase_					,			[[0, 0], [1, 1], [1, 1], [0, 0]]    )
											__lowercase								= self.pooler(UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       str					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int = 2					,			**_UpperCAmelCase  :       Optional[Any]    )						->		Optional[Any]:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= tf.keras.layers.ConvaD(
											    UpperCamelCase_					,			kernel_size=1					,			strides=UpperCamelCase_					,			use_bias=UpperCamelCase_					,			name='convolution'    )
											# Use same default momentum and epsilon as PyTorch equivalent
											__lowercase								= tf.keras.layers.BatchNormalization(epsilon=1e-5					,			momentum=0.9					,			name='normalization'    )





							def       a__			(			self  :       str					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		Tuple:



											"""simple docstring"""


											__lowercase								= x
											__lowercase								= self.convolution(UpperCamelCase_    )
											__lowercase								= self.normalization(UpperCamelCase_					,			training=UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       List[str]					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int = 1					,			_UpperCAmelCase  :       str = "relu"					,			**_UpperCAmelCase  :       Any    )						->		List[Any]:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= in_channels != out_channels or stride != 1
											__lowercase								= TFResNetConvLayer(UpperCamelCase_					,			stride=UpperCamelCase_					,			name='layer.0'    )
											__lowercase								= TFResNetConvLayer(UpperCamelCase_					,			activation=UpperCamelCase_					,			name='layer.1'    )
											__lowercase								= (
											    TFResNetShortCut(UpperCamelCase_					,			stride=UpperCamelCase_					,			name='shortcut'    )
											    if should_apply_shortcut
											    else tf.keras.layers.Activation('linear'					,			name='shortcut'    )
											)
											__lowercase								= ACTaFN[activation]





							def       a__			(			self  :       Union[str, Any]					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		Tuple:



											"""simple docstring"""


											__lowercase								= hidden_state
											__lowercase								= self.conva(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.conva(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.shortcut(UpperCamelCase_					,			training=UpperCamelCase_    )
											hidden_state += residual
											__lowercase								= self.activation(UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       Optional[Any]					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int = 1					,			_UpperCAmelCase  :       str = "relu"					,			_UpperCAmelCase  :       int = 4					,			**_UpperCAmelCase  :       str					,			)						->		Union[str, Any]:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= in_channels != out_channels or stride != 1
											__lowercase								= out_channels // reduction
											__lowercase								= TFResNetConvLayer(UpperCamelCase_					,			kernel_size=1					,			name='layer.0'    )
											__lowercase								= TFResNetConvLayer(UpperCamelCase_					,			stride=UpperCamelCase_					,			name='layer.1'    )
											__lowercase								= TFResNetConvLayer(UpperCamelCase_					,			kernel_size=1					,			activation=UpperCamelCase_					,			name='layer.2'    )
											__lowercase								= (
											    TFResNetShortCut(UpperCamelCase_					,			stride=UpperCamelCase_					,			name='shortcut'    )
											    if should_apply_shortcut
											    else tf.keras.layers.Activation('linear'					,			name='shortcut'    )
											)
											__lowercase								= ACTaFN[activation]





							def       a__			(			self  :       Any					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		str:



											"""simple docstring"""


											__lowercase								= hidden_state
											__lowercase								= self.conva(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.conva(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.conva(UpperCamelCase_					,			training=UpperCamelCase_    )
											__lowercase								= self.shortcut(UpperCamelCase_					,			training=UpperCamelCase_    )
											hidden_state += residual
											__lowercase								= self.activation(UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       str					,			_UpperCAmelCase  :       ResNetConfig					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int					,			_UpperCAmelCase  :       int = 2					,			_UpperCAmelCase  :       int = 2					,			**_UpperCAmelCase  :       Optional[int]    )						->		List[str]:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )

											__lowercase								= TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

											__lowercase								= [layer(UpperCamelCase_					,			UpperCamelCase_					,			stride=UpperCamelCase_					,			activation=config.hidden_act					,			name='layers.0'    )]
											layers += [
											    layer(UpperCamelCase_					,			UpperCamelCase_					,			activation=config.hidden_act					,			name=f"""layers.{i + 1}"""    )
											    for i in range(depth - 1    )
											]
											__lowercase								= layers





							def       a__			(			self  :       List[str]					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False    )						->		Tuple:



											"""simple docstring"""


											for layer in self.stage_layers:
															__lowercase								= layer(UpperCamelCase_					,			training=UpperCamelCase_    )
											return hidden_state


class      A__       (						tf.keras.layers.Layer    ):





							def __init__(			self  :       int					,			_UpperCAmelCase  :       ResNetConfig					,			**_UpperCAmelCase  :       Dict    )						->		Any:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
											__lowercase								= [
											    TFResNetStage(
											        UpperCamelCase_					,			config.embedding_size					,			config.hidden_sizes[0]					,			stride=2 if config.downsample_in_first_stage else 1					,			depth=config.depths[0]					,			name='stages.0'					,			)
											]
											for i, (in_channels, out_channels, depth) in enumerate(
											    zip(config.hidden_sizes					,			config.hidden_sizes[1:]					,			config.depths[1:]    )    ):
															self.stages.append(TFResNetStage(UpperCamelCase_					,			UpperCamelCase_					,			UpperCamelCase_					,			depth=UpperCamelCase_					,			name=f"""stages.{i + 1}"""    )    )





							def       a__			(			self  :       Optional[Any]					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       bool = False					,			_UpperCAmelCase  :       bool = True					,			_UpperCAmelCase  :       bool = False					,			)						->		int:



											"""simple docstring"""


											__lowercase								= () if output_hidden_states else None

											for stage_module in self.stages:
															if output_hidden_states:
																			__lowercase								= hidden_states + (hidden_state,)

															__lowercase								= stage_module(UpperCamelCase_					,			training=UpperCamelCase_    )

											if output_hidden_states:
															__lowercase								= hidden_states + (hidden_state,)

											if not return_dict:
															return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

											return TFBaseModelOutputWithNoAttention(last_hidden_state=UpperCamelCase_					,			hidden_states=UpperCamelCase_    )


class      A__       (						lowercase_    ):
							lowerCAmelCase__		:						Union[str, Any]         =							ResNetConfig
							lowerCAmelCase__		:						Optional[int]         =							"resnet"
							lowerCAmelCase__		:						Any         =							"pixel_values"





							@property
							def       a__			(			self  :       str    )						->		str:



											"""simple docstring"""


											return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)					,			dtype=tf.floataa    )}


SCREAMING_SNAKE_CASE__							=    R"\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"


SCREAMING_SNAKE_CASE__							=    R"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"
@keras_serializable
class      A__       (						tf.keras.layers.Layer    ):
							lowerCAmelCase__		:						Any         =							ResNetConfig





							def __init__(			self  :       str					,			_UpperCAmelCase  :       ResNetConfig					,			**_UpperCAmelCase  :       str    )						->		Any:



											"""simple docstring"""


											super().__init__(**UpperCamelCase_    )
											__lowercase								= config
											__lowercase								= TFResNetEmbeddings(UpperCamelCase_					,			name='embedder'    )
											__lowercase								= TFResNetEncoder(UpperCamelCase_					,			name='encoder'    )
											__lowercase								= tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase_    )





							@unpack_inputs
							def       a__			(			self  :       str					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       Optional[bool] = None					,			_UpperCAmelCase  :       Optional[bool] = None					,			_UpperCAmelCase  :       bool = False					,			)						->		List[Any]:



											"""simple docstring"""


											__lowercase								= (
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											__lowercase								= return_dict if return_dict is not None else self.config.use_return_dict

											# TF 2.0 image layers can't use NCHW format when running on CPU.
											# We transpose to NHWC format and then transpose back after the full forward pass.
											# (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
											__lowercase								= tf.transpose(UpperCamelCase_					,			perm=[0, 2, 3, 1]    )
											__lowercase								= self.embedder(UpperCamelCase_					,			training=UpperCamelCase_    )

											__lowercase								= self.encoder(
											    UpperCamelCase_					,			output_hidden_states=UpperCamelCase_					,			return_dict=UpperCamelCase_					,			training=UpperCamelCase_    )

											__lowercase								= encoder_outputs[0]

											__lowercase								= self.pooler(UpperCamelCase_    )

											# Transpose all the outputs to the NCHW format
											# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
											__lowercase								= tf.transpose(UpperCamelCase_					,			(0, 3, 1, 2)    )
											__lowercase								= tf.transpose(UpperCamelCase_					,			(0, 3, 1, 2)    )
											__lowercase								= ()
											for hidden_state in encoder_outputs[1:]:
															__lowercase								= hidden_states + tuple(tf.transpose(UpperCamelCase_					,			(0, 3, 1, 2)    ) for h in hidden_state    )

											if not return_dict:
															return (last_hidden_state, pooled_output) + hidden_states

											__lowercase								= hidden_states if output_hidden_states else None

											return TFBaseModelOutputWithPoolingAndNoAttention(
											    last_hidden_state=UpperCamelCase_					,			pooler_output=UpperCamelCase_					,			hidden_states=UpperCamelCase_					,			)


@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."   ,						lowercase_   ,						)
class      A__       (						lowercase_    ):





							def __init__(			self  :       int					,			_UpperCAmelCase  :       ResNetConfig					,			**_UpperCAmelCase  :       Dict    )						->		Any:



											"""simple docstring"""


											super().__init__(UpperCamelCase_					,			**UpperCamelCase_    )
											__lowercase								= TFResNetMainLayer(config=UpperCamelCase_					,			name='resnet'    )





							@add_start_docstrings_to_model_forward(UpperCamelCase_    )
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC					,			output_type=UpperCamelCase_					,			config_class=_CONFIG_FOR_DOC					,			modality='vision'					,			expected_output=_EXPECTED_OUTPUT_SHAPE					,			)
							@unpack_inputs
							def       a__			(			self  :       Dict					,			_UpperCAmelCase  :       tf.Tensor					,			_UpperCAmelCase  :       Optional[bool] = None					,			_UpperCAmelCase  :       Optional[bool] = None					,			_UpperCAmelCase  :       bool = False					,			)						->		Dict:



											"""simple docstring"""


											__lowercase								= (
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											__lowercase								= return_dict if return_dict is not None else self.config.use_return_dict

											__lowercase								= self.resnet(
											    pixel_values=UpperCamelCase_					,			output_hidden_states=UpperCamelCase_					,			return_dict=UpperCamelCase_					,			training=UpperCamelCase_					,			)
											return resnet_outputs


@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "   ,						lowercase_   ,						)
class      A__       (						lowercase_   ,						lowercase_    ):





							def __init__(			self  :       int					,			_UpperCAmelCase  :       ResNetConfig					,			**_UpperCAmelCase  :       Any    )						->		str:



											"""simple docstring"""


											super().__init__(UpperCamelCase_					,			**UpperCamelCase_    )
											__lowercase								= config.num_labels
											__lowercase								= TFResNetMainLayer(UpperCamelCase_					,			name='resnet'    )
											# classification head
											__lowercase								= (
											    tf.keras.layers.Dense(config.num_labels					,			name='classifier.1'    )
											    if config.num_labels > 0
											    else tf.keras.layers.Activation('linear'					,			name='classifier.1'    )
											)





							def       a__			(			self  :       Union[str, Any]					,			_UpperCAmelCase  :       tf.Tensor    )						->		Optional[int]:



											"""simple docstring"""


											__lowercase								= tf.keras.layers.Flatten()(UpperCamelCase_    )
											__lowercase								= self.classifier_layer(UpperCamelCase_    )
											return logits





							@add_start_docstrings_to_model_forward(UpperCamelCase_    )
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT					,			output_type=UpperCamelCase_					,			config_class=_CONFIG_FOR_DOC					,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT					,			)
							@unpack_inputs
							def       a__			(			self  :       str					,			_UpperCAmelCase  :       tf.Tensor = None					,			_UpperCAmelCase  :       tf.Tensor = None					,			_UpperCAmelCase  :       bool = None					,			_UpperCAmelCase  :       bool = None					,			_UpperCAmelCase  :       bool = False					,			)						->		Optional[int]:



											"""simple docstring"""


											__lowercase								= return_dict if return_dict is not None else self.config.use_return_dict

											__lowercase								= self.resnet(
											    UpperCamelCase_					,			output_hidden_states=UpperCamelCase_					,			return_dict=UpperCamelCase_					,			training=UpperCamelCase_    )

											__lowercase								= outputs.pooler_output if return_dict else outputs[1]

											__lowercase								= self.classifier(UpperCamelCase_    )

											__lowercase								= None if labels is None else self.hf_compute_loss(UpperCamelCase_					,			UpperCamelCase_    )

											if not return_dict:
															__lowercase								= (logits,) + outputs[2:]
															return (loss,) + output if loss is not None else output

											return TFImageClassifierOutputWithNoAttention(loss=UpperCamelCase_					,			logits=UpperCamelCase_					,			hidden_states=outputs.hidden_states    )







import unittest

from transformers import load_tool
from transformers.tools.agent_types import AGENT_TYPE_MAPPING

from .test_tools_common import ToolTesterMixin, output_types
class      A__       (						unittest.TestCase   ,						lowerCAmelCase__    ):





							def       a__			(			self  :       Any    )						->		Dict:



											"""simple docstring"""


											__lowercase								= load_tool('translation'    )
											self.tool.setup()
											__lowercase								= load_tool('translation'					,			remote=_UpperCAmelCase    )





							def       a__			(			self  :       int    )						->		Optional[Any]:



											"""simple docstring"""


											__lowercase								= self.tool('Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       Tuple    )						->		Optional[int]:



											"""simple docstring"""


											__lowercase								= self.remote_tool('Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





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



											"""simple docstring"""


											__lowercase								= self.tool(text='Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       Tuple    )						->		Optional[Any]:



											"""simple docstring"""


											__lowercase								= self.remote_tool(text='Hey, what\'s up?'					,			src_lang='English'					,			tgt_lang='French'    )
											self.assertEqual(_UpperCAmelCase					,			'- Hé, comment ça va?'    )





							def       a__			(			self  :       List[Any]    )						->		int:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']
											__lowercase								= self.tool(*_UpperCAmelCase    )

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

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





							def       a__			(			self  :       List[str]    )						->		Any:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']
											__lowercase								= self.tool(*_UpperCAmelCase    )

											if not isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
															__lowercase								= [outputs]

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

											for output, output_type in zip(_UpperCAmelCase					,			self.tool.outputs    ):
															__lowercase								= AGENT_TYPE_MAPPING[output_type]
															self.assertTrue(isinstance(_UpperCAmelCase					,			_UpperCAmelCase    )    )





							def       a__			(			self  :       Tuple    )						->		List[Any]:



											"""simple docstring"""


											__lowercase								= ['Hey, what\'s up?', 'English', 'Spanish']

											__lowercase								= []

											for _input, input_type in zip(_UpperCAmelCase					,			self.tool.inputs    ):
															if isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
																			_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
											__lowercase								= self.tool(*_UpperCAmelCase    )

											if not isinstance(_UpperCAmelCase					,			_UpperCAmelCase    ):
															__lowercase								= [outputs]

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





