


'''simple docstring'''
import argparse
import json
from pathlib import Path

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

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
from transformers.utils import logging


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


def 			a      (			__a   )  ->	Optional[Any]:



					'''simple docstring'''






					if "resnet-50" in model_name:
										UpperCamelCase__   :Union[str, Any]												= ResNetConfig.from_pretrained('''microsoft/resnet-50'''   )
					elif "resnet-101" in model_name:
										UpperCamelCase__   :str												= ResNetConfig.from_pretrained('''microsoft/resnet-101'''   )
					else:
										raise ValueError('''Model name should include either resnet50 or resnet101'''   )

					UpperCamelCase__   :Union[str, Any]												= DetrConfig(use_timm_backbone=__lowerCamelCase ,					backbone_config=__lowerCamelCase   )

					# set label attributes
					UpperCamelCase__   :List[Any]												= '''panoptic''' in model_name
					if is_panoptic:
										UpperCamelCase__   :Union[str, Any]												= 250
					else:
										UpperCamelCase__   :List[Any]												= 91
										UpperCamelCase__   :List[str]												= '''huggingface/label-files'''
										UpperCamelCase__   :Union[str, Any]												= '''coco-detection-id2label.json'''
										UpperCamelCase__   :List[str]												= json.load(open(hf_hub_download(__lowerCamelCase ,					__lowerCamelCase ,					repo_type='''dataset'''   ) ,					'''r'''   )   )
										UpperCamelCase__   :str												= {int(__lowerCamelCase   ): v for k, v in idalabel.items()}
										UpperCamelCase__   :List[str]												= idalabel
										UpperCamelCase__   :List[str]												= {v: k for k, v in idalabel.items()}

					return config, is_panoptic


def 			a      (			__a   )  ->	Optional[Any]:



					'''simple docstring'''






					UpperCamelCase__   :Dict												= []

					# stem
					# fmt: off
					rename_keys.append(('''backbone.0.body.conv1.weight''', '''backbone.conv_encoder.model.embedder.embedder.convolution.weight''')   )
					rename_keys.append(('''backbone.0.body.bn1.weight''', '''backbone.conv_encoder.model.embedder.embedder.normalization.weight''')   )
					rename_keys.append(('''backbone.0.body.bn1.bias''', '''backbone.conv_encoder.model.embedder.embedder.normalization.bias''')   )
					rename_keys.append(('''backbone.0.body.bn1.running_mean''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_mean''')   )
					rename_keys.append(('''backbone.0.body.bn1.running_var''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_var''')   )
					# stages
					for stage_idx in range(len(config.backbone_config.depths   )   ):
										for layer_idx in range(config.backbone_config.depths[stage_idx]   ):
															# shortcut
															if layer_idx == 0:
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var''',
																				    )   )
															# 3 convs
															for i in range(3   ):
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean''',
																				    )   )
																				rename_keys.append(
																				    (
																				        f'''backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var''',
																				        f'''backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var''',
																				    )   )
    # fmt: on

					for i in range(config.encoder_layers   ):
										# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
										rename_keys.append(
										    (
										        f'''transformer.encoder.layers.{i}.self_attn.out_proj.weight''',
										        f'''encoder.layers.{i}.self_attn.out_proj.weight''',
										    )   )
										rename_keys.append(
										    (f'''transformer.encoder.layers.{i}.self_attn.out_proj.bias''', f'''encoder.layers.{i}.self_attn.out_proj.bias''')   )
										rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.weight''', f'''encoder.layers.{i}.fc1.weight''')   )
										rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.bias''', f'''encoder.layers.{i}.fc1.bias''')   )
										rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.weight''', f'''encoder.layers.{i}.fc2.weight''')   )
										rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.bias''', f'''encoder.layers.{i}.fc2.bias''')   )
										rename_keys.append(
										    (f'''transformer.encoder.layers.{i}.norm1.weight''', f'''encoder.layers.{i}.self_attn_layer_norm.weight''')   )
										rename_keys.append(
										    (f'''transformer.encoder.layers.{i}.norm1.bias''', f'''encoder.layers.{i}.self_attn_layer_norm.bias''')   )
										rename_keys.append(
										    (f'''transformer.encoder.layers.{i}.norm2.weight''', f'''encoder.layers.{i}.final_layer_norm.weight''')   )
										rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.bias''', f'''encoder.layers.{i}.final_layer_norm.bias''')   )
										# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
										rename_keys.append(
										    (
										        f'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''',
										        f'''decoder.layers.{i}.self_attn.out_proj.weight''',
										    )   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', f'''decoder.layers.{i}.self_attn.out_proj.bias''')   )
										rename_keys.append(
										    (
										        f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.weight''',
										        f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
										    )   )
										rename_keys.append(
										    (
										        f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.bias''',
										        f'''decoder.layers.{i}.encoder_attn.out_proj.bias''',
										    )   )
										rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.weight''', f'''decoder.layers.{i}.fc1.weight''')   )
										rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.bias''', f'''decoder.layers.{i}.fc1.bias''')   )
										rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.weight''', f'''decoder.layers.{i}.fc2.weight''')   )
										rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.bias''', f'''decoder.layers.{i}.fc2.bias''')   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.norm1.weight''', f'''decoder.layers.{i}.self_attn_layer_norm.weight''')   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.norm1.bias''', f'''decoder.layers.{i}.self_attn_layer_norm.bias''')   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.norm2.weight''', f'''decoder.layers.{i}.encoder_attn_layer_norm.weight''')   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.norm2.bias''', f'''decoder.layers.{i}.encoder_attn_layer_norm.bias''')   )
										rename_keys.append(
										    (f'''transformer.decoder.layers.{i}.norm3.weight''', f'''decoder.layers.{i}.final_layer_norm.weight''')   )
										rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.bias''', f'''decoder.layers.{i}.final_layer_norm.bias''')   )

					# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
					rename_keys.extend(
					    [
					        ('''input_proj.weight''', '''input_projection.weight'''),
					        ('''input_proj.bias''', '''input_projection.bias'''),
					        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
					        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
					        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
					        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
					        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
					        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
					        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
					        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
					        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
					        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
					        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
					    ]   )

					return rename_keys


def 			a      (			__a ,					__a ,					__a   )  ->	Dict:



					'''simple docstring'''






					UpperCamelCase__   :List[Any]												= state_dict.pop(__lowerCamelCase   )
					UpperCamelCase__   :Union[str, Any]												= val


def 			a      (			__a ,					__a=False   )  ->	Union[str, Any]:



					'''simple docstring'''






					UpperCamelCase__   :str												= ''''''
					if is_panoptic:
										UpperCamelCase__   :int												= '''detr.'''

					# first: transformer encoder
					for i in range(6   ):
										# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
										UpperCamelCase__   :Dict												= state_dict.pop(f'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'''   )
										UpperCamelCase__   :Any												= state_dict.pop(f'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'''   )
										# next, add query, keys and values (in that order) to the state dict
										UpperCamelCase__   :int												= in_proj_weight[:256, :]
										UpperCamelCase__   :Optional[Any]												= in_proj_bias[:256]
										UpperCamelCase__   :List[Any]												= in_proj_weight[256:512, :]
										UpperCamelCase__   :str												= in_proj_bias[256:512]
										UpperCamelCase__   :Optional[int]												= in_proj_weight[-256:, :]
										UpperCamelCase__   :Union[str, Any]												= in_proj_bias[-256:]
					# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
					for i in range(6   ):
										# read in weights + bias of input projection layer of self-attention
										UpperCamelCase__   :Optional[Any]												= state_dict.pop(f'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'''   )
										UpperCamelCase__   :Any												= state_dict.pop(f'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'''   )
										# next, add query, keys and values (in that order) to the state dict
										UpperCamelCase__   :int												= in_proj_weight[:256, :]
										UpperCamelCase__   :List[Any]												= in_proj_bias[:256]
										UpperCamelCase__   :Union[str, Any]												= in_proj_weight[256:512, :]
										UpperCamelCase__   :Dict												= in_proj_bias[256:512]
										UpperCamelCase__   :Any												= in_proj_weight[-256:, :]
										UpperCamelCase__   :int												= in_proj_bias[-256:]
										# read in weights + bias of input projection layer of cross-attention
										UpperCamelCase__   :int												= state_dict.pop(
										    f'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'''   )
										UpperCamelCase__   :Optional[Any]												= state_dict.pop(f'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'''   )
										# next, add query, keys and values (in that order) of cross-attention to the state dict
										UpperCamelCase__   :Optional[Any]												= in_proj_weight_cross_attn[:256, :]
										UpperCamelCase__   :Dict												= in_proj_bias_cross_attn[:256]
										UpperCamelCase__   :Optional[Any]												= in_proj_weight_cross_attn[256:512, :]
										UpperCamelCase__   :Union[str, Any]												= in_proj_bias_cross_attn[256:512]
										UpperCamelCase__   :Dict												= in_proj_weight_cross_attn[-256:, :]
										UpperCamelCase__   :Optional[int]												= in_proj_bias_cross_attn[-256:]


def 			a      (			)  ->	List[str]:



					'''simple docstring'''






					UpperCamelCase__   :int												= '''http://images.cocodataset.org/val2017/000000039769.jpg'''
					UpperCamelCase__   :Optional[Any]												= Image.open(requests.get(__lowerCamelCase ,					stream=__lowerCamelCase   ).raw   )

					return im


@torch.no_grad()
def 			a      (			__a ,					__a=None ,					__a=False   )  ->	Any:



					'''simple docstring'''






					UpperCamelCase__					,				UpperCamelCase__   :Union[str, Any]												= get_detr_config(__lowerCamelCase   )

					# load original model from torch hub
					UpperCamelCase__   :Optional[Any]												= {
					    '''detr-resnet-50''': '''detr_resnet50''',
					    '''detr-resnet-101''': '''detr_resnet101''',
					}
					logger.info(f'''Converting model {model_name}...'''   )
					UpperCamelCase__   :List[str]												= torch.hub.load('''facebookresearch/detr''' ,					model_name_to_original_name[model_name] ,					pretrained=__lowerCamelCase   ).eval()
					UpperCamelCase__   :List[str]												= detr.state_dict()
					# rename keys
					for src, dest in create_rename_keys(__lowerCamelCase   ):
										if is_panoptic:
															UpperCamelCase__   :Any												= '''detr.''' + src
										rename_key(__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase   )
					# query, key and value matrices need special treatment
					read_in_q_k_v(__lowerCamelCase ,					is_panoptic=__lowerCamelCase   )
					# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
					UpperCamelCase__   :List[str]												= '''detr.model.''' if is_panoptic else '''model.'''
					for key in state_dict.copy().keys():
										if is_panoptic:
															if (
															    key.startswith('''detr'''   )
															    and not key.startswith('''class_labels_classifier'''   )
															    and not key.startswith('''bbox_predictor'''   )
															):
																				UpperCamelCase__   :Union[str, Any]												= state_dict.pop(__lowerCamelCase   )
																				UpperCamelCase__   :Union[str, Any]												= val
															elif "class_labels_classifier" in key or "bbox_predictor" in key:
																				UpperCamelCase__   :Optional[int]												= state_dict.pop(__lowerCamelCase   )
																				UpperCamelCase__   :List[Any]												= val
															elif key.startswith('''bbox_attention'''   ) or key.startswith('''mask_head'''   ):
																				continue
															else:
																				UpperCamelCase__   :Any												= state_dict.pop(__lowerCamelCase   )
																				UpperCamelCase__   :int												= val
										else:
															if not key.startswith('''class_labels_classifier'''   ) and not key.startswith('''bbox_predictor'''   ):
																				UpperCamelCase__   :Optional[int]												= state_dict.pop(__lowerCamelCase   )
																				UpperCamelCase__   :List[str]												= val

    # finally, create HuggingFace model and load state dict
					UpperCamelCase__   :List[Any]												= DetrForSegmentation(__lowerCamelCase   ) if is_panoptic else DetrForObjectDetection(__lowerCamelCase   )
					model.load_state_dict(__lowerCamelCase   )
					model.eval()

					# verify our conversion on an image
					UpperCamelCase__   :List[Any]												= '''coco_panoptic''' if is_panoptic else '''coco_detection'''
					UpperCamelCase__   :str												= DetrImageProcessor(format=__lowerCamelCase   )

					UpperCamelCase__   :Any												= processor(images=prepare_img() ,					return_tensors='''pt'''   )
					UpperCamelCase__   :Tuple												= encoding['''pixel_values''']

					UpperCamelCase__   :Optional[int]												= detr(__lowerCamelCase   )
					UpperCamelCase__   :List[Any]												= model(__lowerCamelCase   )

					assert torch.allclose(outputs.logits ,					original_outputs['''pred_logits'''] ,					atol=1e-3   )
					assert torch.allclose(outputs.pred_boxes ,					original_outputs['''pred_boxes'''] ,					atol=1e-3   )
					if is_panoptic:
										assert torch.allclose(outputs.pred_masks ,					original_outputs['''pred_masks'''] ,					atol=1e-4   )
					print('''Looks ok!'''   )

					if pytorch_dump_folder_path is not None:
										# Save model and image processor
										logger.info(f'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'''   )
										Path(__lowerCamelCase   ).mkdir(exist_ok=__lowerCamelCase   )
										model.save_pretrained(__lowerCamelCase   )
										processor.save_pretrained(__lowerCamelCase   )

					if push_to_hub:
										# Upload model and image processor to the hub
										logger.info('''Uploading PyTorch model and image processor to the hub...'''   )
										model.push_to_hub(f'''nielsr/{model_name}'''   )
										processor.push_to_hub(f'''nielsr/{model_name}'''   )


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

		parser.add_argument(
		    '''--model_name''',
		    default='''detr-resnet-50''',
		    type=str,
		    choices=['''detr-resnet-50''', '''detr-resnet-101'''],
		    help='''Name of the DETR model you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
		)
		parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Whether to push the model to the hub or not.''')
		__snake_case							      =     parser.parse_args()
		convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


__UpperCamelCase					:       List[str]    					=      logging.get_logger(__name__)

__UpperCamelCase					:       Dict[Optional[str], Type[Formatter]]    					=      {}
__UpperCamelCase					:       Dict[Optional[str], str]    					=      {}
__UpperCamelCase					:       Dict[Optional[str], Exception]    					=      {}





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase = None							,			)      ->       Optional[int]:
	a										=							aliases if aliases is not None else []
	if format_type in _FORMAT_TYPES:
		logger.warning(
		    f'Overwriting format type \'{format_type}\' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})'    )
	a										=							formatter_cls
	for alias in set(aliases + [format_type]    ):
		if alias in _FORMAT_TYPES_ALIASES:
			logger.warning(
			    f'Overwriting format type alias \'{alias}\' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})'    )
		a										=							format_type





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase = None    )      ->       List[str]:
	a										=							aliases if aliases is not None else []
	for alias in set(aliases + [format_type]    ):
		a										=							unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=["python"])
_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
_register_formatter(CustomFormatter, "custom")

if config.TORCH_AVAILABLE:
		from .torch_formatter import TorchFormatter

		_register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
else:
		__UpperCamelCase					:       str    					=      ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
		_register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])

if config.TF_AVAILABLE:
		from .tf_formatter import TFFormatter

		_register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
else:
		__UpperCamelCase					:       List[str]    					=      ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
		_register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])

if config.JAX_AVAILABLE:
		from .jax_formatter import JaxFormatter

		_register_formatter(JaxFormatter, "jax", aliases=[])
else:
		__UpperCamelCase					:       List[str]    					=      ValueError("JAX needs to be installed to be able to return JAX arrays.")
		_register_unavailable_formatter(_jax_error, "jax", aliases=[])





def 		__A		(	__lowerCamelCase    )      ->       Optional[str]:
	if format_type in _FORMAT_TYPES_ALIASES:
		return _FORMAT_TYPES_ALIASES[format_type]
	else:
		return format_type





def 		__A		(	__lowerCamelCase							,			**__lowerCamelCase    )      ->       Formatter:
	a										=							get_format_type_from_alias(__lowerCamelCase    )
	if format_type in _FORMAT_TYPES:
		return _FORMAT_TYPES[format_type](**__lowerCamelCase    )
	if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
		raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
	else:
		raise ValueError(
		    f'Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None    )}, but got \'{format_type}\''    )

