



"""simple docstring"""







import argparse
import json
from pathlib import Path

import requests
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BeitConfig,
    BeitForImageClassification,
    BeitForMaskedImageModeling,
    BeitForSemanticSegmentation,
    BeitImageProcessor,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
A     =      logging.get_logger(__name__)

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__=False					,   lowerCamelCase__=False      )			->				List[str]:
							A    =       '''backbone.''' if is_semantic else ''''''

							A    =       []
							for i in range(config.num_hidden_layers      ):
														# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
														rename_keys.append((f"""{prefix}blocks.{i}.norm1.weight""", f"""beit.encoder.layer.{i}.layernorm_before.weight""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.norm1.bias""", f"""beit.encoder.layer.{i}.layernorm_before.bias""")      )
														rename_keys.append(
														    (f"""{prefix}blocks.{i}.attn.proj.weight""", f"""beit.encoder.layer.{i}.attention.output.dense.weight""")      )
														rename_keys.append(
														    (f"""{prefix}blocks.{i}.attn.proj.bias""", f"""beit.encoder.layer.{i}.attention.output.dense.bias""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.norm2.weight""", f"""beit.encoder.layer.{i}.layernorm_after.weight""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.norm2.bias""", f"""beit.encoder.layer.{i}.layernorm_after.bias""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.weight""", f"""beit.encoder.layer.{i}.intermediate.dense.weight""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.bias""", f"""beit.encoder.layer.{i}.intermediate.dense.bias""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.weight""", f"""beit.encoder.layer.{i}.output.dense.weight""")      )
														rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.bias""", f"""beit.encoder.layer.{i}.output.dense.bias""")      )

							# projection layer + position embeddings
							rename_keys.extend(
							    [
							        (f"""{prefix}cls_token""", 'beit.embeddings.cls_token'),
							        (f"""{prefix}patch_embed.proj.weight""", 'beit.embeddings.patch_embeddings.projection.weight'),
							        (f"""{prefix}patch_embed.proj.bias""", 'beit.embeddings.patch_embeddings.projection.bias'),
							    ]      )

							if has_lm_head:
														# mask token + shared relative position bias + layernorm
														rename_keys.extend(
														    [
														        ('mask_token', 'beit.embeddings.mask_token'),
														        (
														            'rel_pos_bias.relative_position_bias_table',
														            'beit.encoder.relative_position_bias.relative_position_bias_table',
														        ),
														        (
														            'rel_pos_bias.relative_position_index',
														            'beit.encoder.relative_position_bias.relative_position_index',
														        ),
														        ('norm.weight', 'layernorm.weight'),
														        ('norm.bias', 'layernorm.bias'),
														    ]      )
							elif is_semantic:
														# semantic segmentation classification heads
														rename_keys.extend(
														    [
														        ('decode_head.conv_seg.weight', 'decode_head.classifier.weight'),
														        ('decode_head.conv_seg.bias', 'decode_head.classifier.bias'),
														        ('auxiliary_head.conv_seg.weight', 'auxiliary_head.classifier.weight'),
														        ('auxiliary_head.conv_seg.bias', 'auxiliary_head.classifier.bias'),
														    ]      )
							else:
														# layernorm + classification head
														rename_keys.extend(
														    [
														        ('fc_norm.weight', 'beit.pooler.layernorm.weight'),
														        ('fc_norm.bias', 'beit.pooler.layernorm.bias'),
														        ('head.weight', 'classifier.weight'),
														        ('head.bias', 'classifier.bias'),
														    ]      )

							return rename_keys

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__					,   lowerCamelCase__=False					,   lowerCamelCase__=False      )			->				Dict:
							for i in range(config.num_hidden_layers      ):
														A    =       '''backbone.''' if is_semantic else ''''''
														# queries, keys and values
														A    =       state_dict.pop(f"""{prefix}blocks.{i}.attn.qkv.weight"""      )
														A    =       state_dict.pop(f"""{prefix}blocks.{i}.attn.q_bias"""      )
														A    =       state_dict.pop(f"""{prefix}blocks.{i}.attn.v_bias"""      )

														A    =       in_proj_weight[
														    : config.hidden_size, :
														]
														A    =       q_bias
														A    =       in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														A    =       in_proj_weight[
														    -config.hidden_size :, :
														]
														A    =       v_bias

														# gamma_1 and gamma_2
														# we call them lambda because otherwise they are renamed when using .from_pretrained
														A    =       state_dict.pop(f"""{prefix}blocks.{i}.gamma_1"""      )
														A    =       state_dict.pop(f"""{prefix}blocks.{i}.gamma_2"""      )

														A    =       gamma_a
														A    =       gamma_a

														# relative_position bias table + index
														if not has_lm_head:
																					# each layer has its own relative position bias
																					A    =       state_dict.pop(f"""{prefix}blocks.{i}.attn.relative_position_bias_table"""      )
																					A    =       state_dict.pop(f"""{prefix}blocks.{i}.attn.relative_position_index"""      )

																					A    =       table
																					A    =       index

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__					,   lowerCamelCase__      )			->				Dict:
							A    =       dct.pop(UpperCamelCase__      )
							A    =       val

def 	lowerCAmelCase__      (  )			->				Optional[int]:
							A    =       '''http://images.cocodataset.org/val2017/000000039769.jpg'''
							A    =       Image.open(requests.get(UpperCamelCase__					,   stream=UpperCamelCase__      ).raw      )
							return im

@torch.no_grad()
def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__      )			->				List[str]:
							A    =       BeitConfig()
							A    =       False
							A    =       False
							A    =       '''huggingface/label-files'''
							# set config parameters based on URL
							if checkpoint_url[-9:-4] == "pt22k":
														# masked image modeling
														A    =       True
														A    =       True
														A    =       True
							elif checkpoint_url[-9:-4] == "ft22k":
														# intermediate fine-tuning on ImageNet-22k
														A    =       True
														A    =       21841
														A    =       '''imagenet-22k-id2label.json'''
														A    =       json.load(open(hf_hub_download(UpperCamelCase__					,   UpperCamelCase__					,   repo_type='dataset'      )					,   'r'      )      )
														A    =       {int(UpperCamelCase__      ): v for k, v in idalabel.items()}
														# this dataset contains 21843 labels but the model only has 21841
														# we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
														del idalabel[9205]
														del idalabel[15027]
														A    =       idalabel
														A    =       {v: k for k, v in idalabel.items()}
							elif checkpoint_url[-8:-4] == "to1k":
														# fine-tuning on ImageNet-1k
														A    =       True
														A    =       1000
														A    =       '''imagenet-1k-id2label.json'''
														A    =       json.load(open(hf_hub_download(UpperCamelCase__					,   UpperCamelCase__					,   repo_type='dataset'      )					,   'r'      )      )
														A    =       {int(UpperCamelCase__      ): v for k, v in idalabel.items()}
														A    =       idalabel
														A    =       {v: k for k, v in idalabel.items()}
														if "384" in checkpoint_url:
																					A    =       384
														if "512" in checkpoint_url:
																					A    =       512
							elif "ade20k" in checkpoint_url:
														# fine-tuning
														A    =       True
														A    =       150
														A    =       '''ade20k-id2label.json'''
														A    =       json.load(open(hf_hub_download(UpperCamelCase__					,   UpperCamelCase__					,   repo_type='dataset'      )					,   'r'      )      )
														A    =       {int(UpperCamelCase__      ): v for k, v in idalabel.items()}
														A    =       idalabel
														A    =       {v: k for k, v in idalabel.items()}
														A    =       640
														A    =       True
							else:
														raise ValueError('Checkpoint not supported, URL should either end with \'pt22k\', \'ft22k\', \'to1k\' or \'ade20k\''      )

							# size of the architecture
							if "base" in checkpoint_url:
														pass
							elif "large" in checkpoint_url:
														A    =       1024
														A    =       4096
														A    =       24
														A    =       16
														if "ade20k" in checkpoint_url:
																					A    =       640
																					A    =       [7, 11, 15, 23]
							else:
														raise ValueError('Should either find \'base\' or \'large\' in checkpoint URL'      )

							# load state_dict of original model, remove and rename some keys
							A    =       torch.hub.load_state_dict_from_url(UpperCamelCase__					,   map_location='cpu'					,   check_hash=UpperCamelCase__      )
							A    =       state_dict['''model'''] if '''ade20k''' not in checkpoint_url else state_dict['''state_dict''']

							A    =       create_rename_keys(UpperCamelCase__					,   has_lm_head=UpperCamelCase__					,   is_semantic=UpperCamelCase__      )
							for src, dest in rename_keys:
														rename_key(UpperCamelCase__					,   UpperCamelCase__					,   UpperCamelCase__      )
							read_in_q_k_v(UpperCamelCase__					,   UpperCamelCase__					,   has_lm_head=UpperCamelCase__					,   is_semantic=UpperCamelCase__      )
							if is_semantic:
														# add prefix to decoder keys
														for key, val in state_dict.copy().items():
																					A    =       state_dict.pop(UpperCamelCase__      )
																					if key.startswith('backbone.fpn'      ):
																												A    =       key.replace('backbone.fpn'					,   'fpn'      )
																					A    =       val

    # load HuggingFace model
							if checkpoint_url[-9:-4] == "pt22k":
														A    =       BeitForMaskedImageModeling(UpperCamelCase__      )
							elif "ade20k" in checkpoint_url:
														A    =       BeitForSemanticSegmentation(UpperCamelCase__      )
							else:
														A    =       BeitForImageClassification(UpperCamelCase__      )
							model.eval()
							model.load_state_dict(UpperCamelCase__      )

							# Check outputs on an image
							if is_semantic:
														A    =       BeitImageProcessor(size=config.image_size					,   do_center_crop=UpperCamelCase__      )
														A    =       load_dataset('hf-internal-testing/fixtures_ade20k'					,   split='test'      )
														A    =       Image.open(ds[0]['file']      )
							else:
														A    =       BeitImageProcessor(
														    size=config.image_size					,   resample=PILImageResampling.BILINEAR					,   do_center_crop=UpperCamelCase__      )
														A    =       prepare_img()

							A    =       image_processor(images=UpperCamelCase__					,   return_tensors='pt'      )
							A    =       encoding['''pixel_values''']

							A    =       model(UpperCamelCase__      )
							A    =       outputs.logits

							# verify logits
							A    =       torch.Size([1, 1000]      )
							if checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k'      ):
														A    =       torch.Size([1, 196, 8192]      )
							elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k'      ):
														A    =       torch.Size([1, 196, 8192]      )
							elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22k'      ):
														A    =       torch.Size([1, 21841]      )
														A    =       torch.tensor([2.22_88, 2.46_71, 0.73_95]      )
														A    =       2397
							elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22k'      ):
														A    =       torch.Size([1, 21841]      )
														A    =       torch.tensor([1.68_81, -0.27_87, 0.59_01]      )
														A    =       2396
							elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft1k'      ):
														A    =       torch.tensor([0.12_41, 0.07_98, -0.65_69]      )
														A    =       285
							elif checkpoint_url[:-4].endswith('beit_base_patch16_224_pt22k_ft22kto1k'      ):
														A    =       torch.tensor([-1.23_85, -1.09_87, -1.01_08]      )
														A    =       281
							elif checkpoint_url[:-4].endswith('beit_base_patch16_384_pt22k_ft22kto1k'      ):
														A    =       torch.tensor([-1.53_03, -0.94_84, -0.31_47]      )
														A    =       761
							elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft1k'      ):
														A    =       torch.tensor([0.46_10, -0.09_28, 0.20_86]      )
														A    =       761
							elif checkpoint_url[:-4].endswith('beit_large_patch16_224_pt22k_ft22kto1k'      ):
														A    =       torch.tensor([-0.48_04, 0.62_57, -0.18_37]      )
														A    =       761
							elif checkpoint_url[:-4].endswith('beit_large_patch16_384_pt22k_ft22kto1k'      ):
														A    =       torch.tensor([[-0.51_22, 0.51_17, -0.21_13]]      )
														A    =       761
							elif checkpoint_url[:-4].endswith('beit_large_patch16_512_pt22k_ft22kto1k'      ):
														A    =       torch.tensor([-0.30_62, 0.72_61, 0.48_52]      )
														A    =       761
							elif checkpoint_url[:-4].endswith('beit_base_patch16_640_pt22k_ft22ktoade20k'      ):
														A    =       (1, 150, 160, 160)
														A    =       torch.tensor(
														    [
														        [[-4.92_25, -2.39_54, -3.05_22], [-2.88_22, -1.00_46, -1.75_61], [-2.95_49, -1.32_28, -2.13_47]],
														        [[-5.81_68, -3.41_29, -4.07_78], [-3.86_51, -2.22_14, -3.02_77], [-3.83_56, -2.46_43, -3.35_35]],
														        [[-0.00_78, 3.99_52, 4.07_54], [2.98_56, 4.69_44, 5.00_35], [3.24_13, 4.78_13, 4.99_69]],
														    ]      )
							elif checkpoint_url[:-4].endswith('beit_large_patch16_640_pt22k_ft22ktoade20k'      ):
														A    =       (1, 150, 160, 160)
														A    =       torch.tensor(
														    [
														        [[-4.33_05, -2.30_49, -3.01_61], [-2.95_91, -1.53_05, -2.22_51], [-3.41_98, -1.80_04, -2.90_62]],
														        [[-5.89_22, -3.74_35, -4.39_78], [-4.20_63, -2.78_72, -3.47_55], [-4.27_91, -3.18_74, -4.16_81]],
														        [[0.98_95, 4.34_67, 4.76_63], [4.24_76, 5.68_30, 6.15_18], [4.55_50, 6.24_95, 6.51_54]],
														    ]      )
							else:
														raise ValueError('Can\'t verify logits as model is not supported'      )

							assert logits.shape == expected_shape, "Shape of logits not as expected"
							if not has_lm_head:
														if is_semantic:
																					assert torch.allclose(
																					    logits[0, :3, :3, :3]					,   UpperCamelCase__					,   atol=1E-3      ), "First elements of logits not as expected"
														else:
																					print('Predicted class idx:'					,   logits.argmax(-1      ).item()      )
																					assert torch.allclose(
																					    logits[0, :3]					,   UpperCamelCase__					,   atol=1E-3      ), "First elements of logits not as expected"
																					assert logits.argmax(-1      ).item() == expected_class_idx, "Predicted class index not as expected"

							Path(UpperCamelCase__      ).mkdir(exist_ok=UpperCamelCase__      )
							print(f"""Saving model to {pytorch_dump_folder_path}"""      )
							model.save_pretrained(UpperCamelCase__      )
							print(f"""Saving image processor to {pytorch_dump_folder_path}"""      )
							image_processor.save_pretrained(UpperCamelCase__      )


if __name__ == "__main__":
							A     =      argparse.ArgumentParser()

							parser.add_argument(
							    '--checkpoint_url',
							    default='https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22kto1k.pth',
							    type=str,
							    help='URL to the original PyTorch checkpoint (.pth file).',
							)
							parser.add_argument(
							    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
							)
							A     =      parser.parse_args()
							convert_beit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








'''simple docstring'''



import os
import pathlib
import tempfile
import uuid

import numpy as np

from ..utils import is_soundfile_availble, is_torch_available, is_vision_available, logging


_lowercase       :						Dict						=logging.get_logger(__name__)

if is_vision_available():
				import PIL.Image
				from PIL import Image
				from PIL.Image import Image as ImageType
else:
				_lowercase       :						List[Any]						=object

if is_torch_available():
				import torch

if is_soundfile_availble():
				import soundfile as sf






class 			_SCREAMING_SNAKE_CASE				:



			def __init__(     self		:						List[str]    ,			__UpperCamelCase		:						Optional[int]			)      ->      List[str]:
							"""simple docstring"""





							snake_case__      :   int      =    value



			def __str__(     self		:						int			)      ->      str:
							"""simple docstring"""





							return self.to_string()



			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      List[str]:
							"""simple docstring"""





							logger.error(
							    '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''			)
							return self._value







			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      str:
							"""simple docstring"""





							logger.error(
							    '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''			)
							return str(self._value			)






class 			_SCREAMING_SNAKE_CASE				(lowercase__,	lowercase__      ):



			def 				lowerCAmelCase (     self		:						str			)      ->      Tuple:
							"""simple docstring"""





							return self._value







			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      Union[str, Any]:
							"""simple docstring"""





							return self._value






class 			_SCREAMING_SNAKE_CASE				(lowercase__,	lowercase__      ):



			def __init__(     self		:						str    ,			__UpperCamelCase		:						List[Any]			)      ->      Dict:
							"""simple docstring"""





							super().__init__(__UpperCamelCase			)

							if not is_vision_available():
											raise ImportError('''PIL must be installed in order to handle images.'''			)

							snake_case__      :   str      =    None
							snake_case__      :   List[Any]      =    None
							snake_case__      :   Tuple      =    None

							if isinstance(__UpperCamelCase    ,			__UpperCamelCase			):
											snake_case__      :   List[Any]      =    value
							elif isinstance(__UpperCamelCase    ,			(str, pathlib.Path)			):
											snake_case__      :   int      =    value
							elif isinstance(__UpperCamelCase    ,			torch.Tensor			):
											snake_case__      :   Union[str, Any]      =    value
							else:
											raise ValueError(F'''Unsupported type for {self.__class__.__name__}: {type(__UpperCamelCase			)}'''			)



			def 				lowerCAmelCase (     self		:						str    ,			__UpperCamelCase		:						Dict=None    ,			__UpperCamelCase		:						Any=None			)      ->      List[Any]:
							"""simple docstring"""





							from IPython.display import Image, display

							display(Image(self.to_string()			)			)



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





							if self._raw is not None:
											return self._raw

							if self._path is not None:
											snake_case__      :   str      =    Image.open(self._path			)
											return self._raw







			def 				lowerCAmelCase (     self		:						Dict			)      ->      Optional[Any]:
							"""simple docstring"""





							if self._path is not None:
											return self._path

							if self._raw is not None:
											snake_case__      :   Any      =    tempfile.mkdtemp()
											snake_case__      :   Dict      =    os.path.join(__UpperCamelCase    ,			str(uuid.uuida()			) + '''.png'''			)
											self._raw.save(self._path			)

											return self._path

							if self._tensor is not None:
											snake_case__      :   List[str]      =    self._tensor.cpu().detach().numpy()

											# There is likely simpler than load into image into save
											snake_case__      :   List[Any]      =    Image.fromarray((array * 255).astype(np.uinta			)			)

											snake_case__      :   str      =    tempfile.mkdtemp()
											snake_case__      :   Dict      =    os.path.join(__UpperCamelCase    ,			str(uuid.uuida()			) + '''.png'''			)

											img.save(self._path			)

											return self._path






class 			_SCREAMING_SNAKE_CASE				(lowercase__      ):



			def __init__(     self		:						Optional[Any]    ,			__UpperCamelCase		:						List[Any]    ,			__UpperCamelCase		:						str=16000			)      ->      Union[str, Any]:
							"""simple docstring"""





							super().__init__(__UpperCamelCase			)

							if not is_soundfile_availble():
											raise ImportError('''soundfile must be installed in order to handle audio.'''			)

							snake_case__      :   List[str]      =    None
							snake_case__      :   Optional[int]      =    None

							snake_case__      :   Any      =    samplerate

							if isinstance(__UpperCamelCase    ,			(str, pathlib.Path)			):
											snake_case__      :   int      =    value
							elif isinstance(__UpperCamelCase    ,			torch.Tensor			):
											snake_case__      :   int      =    value
							else:
											raise ValueError(F'''Unsupported audio type: {type(__UpperCamelCase			)}'''			)



			def 				lowerCAmelCase (     self		:						Tuple    ,			__UpperCamelCase		:						List[Any]=None    ,			__UpperCamelCase		:						Optional[Any]=None			)      ->      Any:
							"""simple docstring"""





							from IPython.display import Audio, display

							display(Audio(self.to_string()    ,			rate=self.samplerate			)			)



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





							if self._tensor is not None:
											return self._tensor

							if self._path is not None:
											snake_case__  ,      snake_case__      :   Tuple      =    sf.read(self._path			)
											snake_case__      :   Tuple      =    torch.tensor(__UpperCamelCase			)
											return self._tensor







			def 				lowerCAmelCase (     self		:						Any			)      ->      Dict:
							"""simple docstring"""





							if self._path is not None:
											return self._path

							if self._tensor is not None:
											snake_case__      :   Tuple      =    tempfile.mkdtemp()
											snake_case__      :   int      =    os.path.join(__UpperCamelCase    ,			str(uuid.uuida()			) + '''.wav'''			)
											sf.write(self._path    ,			self._tensor    ,			samplerate=self.samplerate			)
											return self._path



_lowercase       :						Union[str, Any]						={"text": AgentText, "image": AgentImage, "audio": AgentAudio}
_lowercase       :						List[Any]						={str: AgentText}

if is_vision_available():
				_lowercase       :						Optional[Any]						=AgentImage


def 							__UpperCAmelCase				(				*UpperCamelCase__				:Optional[int]   ,				**UpperCamelCase__				:List[Any]			)		->						Optional[Any]:
				snake_case__      :   List[str]      =    [(arg.to_raw() if isinstance(UpperCamelCase__   ,				UpperCamelCase__			) else arg) for arg in args]
				snake_case__      :   Any      =    {k: (v.to_raw() if isinstance(UpperCamelCase__   ,				UpperCamelCase__			) else v) for k, v in kwargs.items()}
				return args, kwargs



def 							__UpperCAmelCase				(				UpperCamelCase__				:Optional[Any]   ,				UpperCamelCase__				:Tuple=None			)		->						Dict:
				if isinstance(UpperCamelCase__   ,				UpperCamelCase__			):
								snake_case__      :   Any      =    {}
								for i, (k, v) in enumerate(outputs.items()			):
												if output_types is not None:
																# If the class has defined outputs, we can map directly according to the class definition
																if output_types[i] in AGENT_TYPE_MAPPING:
																				snake_case__      :   List[Any]      =    AGENT_TYPE_MAPPING[output_types[i]](UpperCamelCase__			)
																else:
																				snake_case__      :   Optional[int]      =    AgentType(UpperCamelCase__			)

												else:
																# If the class does not have defined output, then we map according to the type
																for _k, _v in INSTANCE_TYPE_MAPPING.items():
																				if isinstance(UpperCamelCase__   ,				_k			):
																								snake_case__      :   str      =    _v(UpperCamelCase__			)
																if k not in decoded_outputs:
																				snake_case__      :   Any      =    AgentType[v]

				elif isinstance(UpperCamelCase__   ,				(list, tuple)			):
								snake_case__      :   List[str]      =    type(UpperCamelCase__			)()
								for i, v in enumerate(UpperCamelCase__			):
												if output_types is not None:
																# If the class has defined outputs, we can map directly according to the class definition
																if output_types[i] in AGENT_TYPE_MAPPING:
																				decoded_outputs.append(AGENT_TYPE_MAPPING[output_types[i]](UpperCamelCase__			)			)
																else:
																				decoded_outputs.append(AgentType(UpperCamelCase__			)			)
												else:
																# If the class does not have defined output, then we map according to the type
																snake_case__      :   Any      =    False
																for _k, _v in INSTANCE_TYPE_MAPPING.items():
																				if isinstance(UpperCamelCase__   ,				_k			):
																								decoded_outputs.append(_v(UpperCamelCase__			)			)
																								snake_case__      :   str      =    True

																if not found:
																				decoded_outputs.append(AgentType(UpperCamelCase__			)			)

				else:
								if output_types[0] in AGENT_TYPE_MAPPING:
												# If the class has defined outputs, we can map directly according to the class definition
												snake_case__      :   Tuple      =    AGENT_TYPE_MAPPING[output_types[0]](UpperCamelCase__			)

								else:
												# If the class does not have defined output, then we map according to the type
												for _k, _v in INSTANCE_TYPE_MAPPING.items():
																if isinstance(UpperCamelCase__   ,				_k			):
																				return _v(UpperCamelCase__			)
												return AgentType(UpperCamelCase__			)

				return decoded_outputs




