




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class  __magic_name__						(  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							str	      =					KandinskyImgaImgPipeline
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					["prompt", "image_embeds", "negative_image_embeds", "image"]
				SCREAMING_SNAKE_CASE__					:							Optional[Any]	      =					[
				    "prompt",
				    "negative_prompt",
				    "image_embeds",
				    "negative_image_embeds",
				    "image",
				]
				SCREAMING_SNAKE_CASE__					:							Any	      =					[
				    "generator",
				    "height",
				    "width",
				    "strength",
				    "guidance_scale",
				    "negative_prompt",
				    "num_inference_steps",
				    "return_dict",
				    "guidance_scale",
				    "num_images_per_prompt",
				    "output_type",
				    "return_dict",
				]
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					False


				@property
				def     _A							(							self:   List[Any]		):
											return 32


				@property
				def     _A							(							self:   Tuple		):
											return 32


				@property
				def     _A							(							self:   int		):
											return self.time_input_dim


				@property
				def     _A							(							self:   int		):
											return self.time_input_dim * 4


				@property
				def     _A							(							self:   Optional[Any]		):
											return 1_00


				@property
				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''		)
											return tokenizer


				@property
				def     _A							(							self:   Dict		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    MCLIPConfig(
											    numDims=self.cross_attention_dim		,					transformerDimensions=self.text_embedder_hidden_size		,					hidden_size=self.text_embedder_hidden_size		,					intermediate_size=37		,					num_attention_heads=4		,					num_hidden_layers=5		,					vocab_size=10_05		,					)

											SCREAMING_SNAKE_CASE_   	=    MultilingualCLIP(UpperCamelCase__		)
											SCREAMING_SNAKE_CASE_   	=    text_encoder.eval()

											return text_encoder


				@property
				def     _A							(							self:   str		):
											torch.manual_seed(0		)

											SCREAMING_SNAKE_CASE_   	=    {
											    '''in_channels''': 4,
											    # Out channels is double in channels because predicts mean and variance
											    '''out_channels''': 8,
											    '''addition_embed_type''': '''text_image''',
											    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
											    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
											    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
											    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
											    '''layers_per_block''': 1,
											    '''encoder_hid_dim''': self.text_embedder_hidden_size,
											    '''encoder_hid_dim_type''': '''text_image_proj''',
											    '''cross_attention_dim''': self.cross_attention_dim,
											    '''attention_head_dim''': 4,
											    '''resnet_time_scale_shift''': '''scale_shift''',
											    '''class_embed_type''': None,
											}

											SCREAMING_SNAKE_CASE_   	=    UNetaDConditionModel(**UpperCamelCase__		)
											return model


				@property
				def     _A							(							self:   Optional[Any]		):
											return {
											    "block_out_channels": [32, 64],
											    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
											    "in_channels": 3,
											    "latent_channels": 4,
											    "layers_per_block": 1,
											    "norm_num_groups": 8,
											    "norm_type": "spatial",
											    "num_vq_embeddings": 12,
											    "out_channels": 3,
											    "up_block_types": [
											        "AttnUpDecoderBlock2D",
											        "UpDecoderBlock2D",
											    ],
											    "vq_embed_dim": 4,
											}


				@property
				def     _A							(							self:   List[Any]		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    VQModel(**self.dummy_movq_kwargs		)
											return model


				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.dummy_text_encoder
											SCREAMING_SNAKE_CASE_   	=    self.dummy_tokenizer
											SCREAMING_SNAKE_CASE_   	=    self.dummy_unet
											SCREAMING_SNAKE_CASE_   	=    self.dummy_movq

											SCREAMING_SNAKE_CASE_   	=    {
											    '''num_train_timesteps''': 10_00,
											    '''beta_schedule''': '''linear''',
											    '''beta_start''': 0.0_00_85,
											    '''beta_end''': 0.0_12,
											    '''clip_sample''': False,
											    '''set_alpha_to_one''': False,
											    '''steps_offset''': 0,
											    '''prediction_type''': '''epsilon''',
											    '''thresholding''': False,
											}

											SCREAMING_SNAKE_CASE_   	=    DDIMScheduler(**UpperCamelCase__		)

											SCREAMING_SNAKE_CASE_   	=    {
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''movq''': movq,
											}

											return components


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Dict=0		):
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, self.cross_attention_dim)		,					rng=random.Random(UpperCamelCase__		)		).to(UpperCamelCase__		)
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, self.cross_attention_dim)		,					rng=random.Random(seed + 1		)		).to(UpperCamelCase__		)
											# create init_image
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, 3, 64, 64)		,					rng=random.Random(UpperCamelCase__		)		).to(UpperCamelCase__		)
											SCREAMING_SNAKE_CASE_   	=    image.cpu().permute(0		,					2		,					3		,					1		)[0]
											SCREAMING_SNAKE_CASE_   	=    Image.fromarray(np.uinta(UpperCamelCase__		)		).convert('''RGB'''		).resize((2_56, 2_56)		)

											if str(UpperCamelCase__		).startswith('''mps'''		):
																		SCREAMING_SNAKE_CASE_   	=    torch.manual_seed(UpperCamelCase__		)
											else:
																		SCREAMING_SNAKE_CASE_   	=    torch.Generator(device=UpperCamelCase__		).manual_seed(UpperCamelCase__		)
											SCREAMING_SNAKE_CASE_   	=    {
											    '''prompt''': '''horse''',
											    '''image''': init_image,
											    '''image_embeds''': image_embeds,
											    '''negative_image_embeds''': negative_image_embeds,
											    '''generator''': generator,
											    '''height''': 64,
											    '''width''': 64,
											    '''num_inference_steps''': 10,
											    '''guidance_scale''': 7.0,
											    '''strength''': 0.2,
											    '''output_type''': '''np''',
											}
											return inputs





				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    '''cpu'''

											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_components()

											SCREAMING_SNAKE_CASE_   	=    self.pipeline_class(**UpperCamelCase__		)
											SCREAMING_SNAKE_CASE_   	=    pipe.to(UpperCamelCase__		)

											pipe.set_progress_bar_config(disable=UpperCamelCase__		)

											SCREAMING_SNAKE_CASE_   	=    pipe(**self.get_dummy_inputs(UpperCamelCase__		)		)
											SCREAMING_SNAKE_CASE_   	=    output.images

											SCREAMING_SNAKE_CASE_   	=    pipe(
											    **self.get_dummy_inputs(UpperCamelCase__		)		,					return_dict=UpperCamelCase__		,					)[0]

											SCREAMING_SNAKE_CASE_   	=    image[0, -3:, -3:, -1]
											SCREAMING_SNAKE_CASE_   	=    image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)

											SCREAMING_SNAKE_CASE_   	=    np.array(
											    [0.61_47_49_43, 0.6_07_35_39, 0.43_30_85_44, 0.5_92_82_69, 0.47_49_35_95, 0.46_75_59_73, 0.4_61_38_38, 0.45_36_87_97, 0.50_11_92_33]		)
											assert (
											    np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
											), f" expected_slice {expected_slice}, but got {image_slice.flatten()}"
											assert (
											    np.abs(image_from_tuple_slice.flatten() - expected_slice		).max() < 1E-2
											), f" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"






@slow
@require_torch_gpu
class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







				def     _A							(							self:   List[str]		):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/kandinsky/kandinsky_img2img_frog.npy'''		)

											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''		)
											SCREAMING_SNAKE_CASE_   	=    '''A red cartoon frog, 4k'''

											SCREAMING_SNAKE_CASE_   	=    KandinskyPriorPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-1-prior'''		,					torch_dtype=torch.floataa		)
											pipe_prior.to(UpperCamelCase__		)

											SCREAMING_SNAKE_CASE_   	=    KandinskyImgaImgPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-1'''		,					torch_dtype=torch.floataa		)
											SCREAMING_SNAKE_CASE_   	=    pipeline.to(UpperCamelCase__		)

											pipeline.set_progress_bar_config(disable=UpperCamelCase__		)

											SCREAMING_SNAKE_CASE_   	=    torch.Generator(device='''cpu'''		).manual_seed(0		)
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    pipe_prior(
											    UpperCamelCase__		,					generator=UpperCamelCase__		,					num_inference_steps=5		,					negative_prompt=''''''		,					).to_tuple()

											SCREAMING_SNAKE_CASE_   	=    pipeline(
											    UpperCamelCase__		,					image=UpperCamelCase__		,					image_embeds=UpperCamelCase__		,					negative_image_embeds=UpperCamelCase__		,					generator=UpperCamelCase__		,					num_inference_steps=1_00		,					height=7_68		,					width=7_68		,					strength=0.2		,					output_type='''np'''		,					)

											SCREAMING_SNAKE_CASE_   	=    output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase__		,					UpperCamelCase__		)








import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
			import torch

			from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin






class  __magic_name__						:
				'''simple docstring'''







				def __init__(							self:   Optional[int]		,					_lowerCamelCase:   Tuple		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   Any=None		,					_lowerCamelCase:   Tuple=None		,					_lowerCamelCase:   Optional[Any]="resnet50"		,					_lowerCamelCase:   Any=3		,					_lowerCamelCase:   Optional[int]=32		,					_lowerCamelCase:   List[Any]=3		,					_lowerCamelCase:   int=True		,					_lowerCamelCase:   Any=True		,					):
											SCREAMING_SNAKE_CASE_   	=    parent
											SCREAMING_SNAKE_CASE_   	=    out_indices if out_indices is not None else [4]
											SCREAMING_SNAKE_CASE_   	=    stage_names
											SCREAMING_SNAKE_CASE_   	=    out_features
											SCREAMING_SNAKE_CASE_   	=    backbone
											SCREAMING_SNAKE_CASE_   	=    batch_size
											SCREAMING_SNAKE_CASE_   	=    image_size
											SCREAMING_SNAKE_CASE_   	=    num_channels
											SCREAMING_SNAKE_CASE_   	=    use_pretrained_backbone
											SCREAMING_SNAKE_CASE_   	=    is_training


				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
											SCREAMING_SNAKE_CASE_   	=    self.get_config()

											return config, pixel_values


				def     _A							(							self:   List[Any]		):
											return TimmBackboneConfig(
											    image_size=self.image_size		,					num_channels=self.num_channels		,					out_features=self.out_features		,					out_indices=self.out_indices		,					stage_names=self.stage_names		,					use_pretrained_backbone=self.use_pretrained_backbone		,					backbone=self.backbone		,					)


				def     _A							(							self:   str		,					_lowerCamelCase:   str		,					_lowerCamelCase:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    TimmBackbone(config=_lowerCamelCase		)
											model.to(_lowerCamelCase		)
											model.eval()
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(
											    result.feature_map[-1].shape		,					(self.batch_size, model.channels[-1], 14, 14)		,					)





				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    config_and_inputs
											SCREAMING_SNAKE_CASE_   	=    {'''pixel_values''': pixel_values}
											return config, inputs_dict






@require_torch
@require_timm
class  __magic_name__						(  __UpperCAmelCase    ,  __UpperCAmelCase    ,  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							List[str]	      =					(TimmBackbone,) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE__					:							List[str]	      =					{"feature-extraction": TimmBackbone} if is_torch_available() else {}
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					False
				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					False
				SCREAMING_SNAKE_CASE__					:							Any	      =					False
				SCREAMING_SNAKE_CASE__					:							Any	      =					False


				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    TimmBackboneModelTester(self		)
											SCREAMING_SNAKE_CASE_   	=    ConfigTester(self		,					config_class=_lowerCamelCase		,					has_text_modality=_lowerCamelCase		)


				def     _A							(							self:   str		):
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()


				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    '''resnet18'''
											SCREAMING_SNAKE_CASE_   	=    '''microsoft/resnet-18'''

											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		,					use_timm_backbone=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		)

											self.assertEqual(len(timm_model.out_features		)		,					len(transformers_model.out_features		)		)
											self.assertEqual(len(timm_model.stage_names		)		,					len(transformers_model.stage_names		)		)
											self.assertEqual(timm_model.channels		,					transformers_model.channels		)
											# Out indices are set to the last layer by default. For timm models, we don't know
											# the number of layers in advance, so we set it to (-1,), whereas for transformers
											# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
											self.assertEqual(timm_model.out_indices		,					(-1,)		)
											self.assertEqual(transformers_model.out_indices		,					[len(timm_model.stage_names		) - 1]		)

											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		,					use_timm_backbone=_lowerCamelCase		,					out_indices=[1, 2, 3]		)
											SCREAMING_SNAKE_CASE_   	=    AutoBackbone.from_pretrained(_lowerCamelCase		,					out_indices=[1, 2, 3]		)

											self.assertEqual(timm_model.out_indices		,					transformers_model.out_indices		)
											self.assertEqual(len(timm_model.out_features		)		,					len(transformers_model.out_features		)		)
											self.assertEqual(timm_model.channels		,					transformers_model.channels		)


				@unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''		)
				def     _A							(							self:   Optional[Any]		):
											pass


				@unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''		)
				def     _A							(							self:   Any		):
											pass


				@unittest.skip('''TimmBackbone initialization is managed on the timm side'''		)
				def     _A							(							self:   Dict		):
											pass


				@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''		)
				def     _A							(							self:   Optional[Any]		):
											pass


				@unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''		)
				def     _A							(							self:   List[Any]		):
											pass


				@unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''		)
				def     _A							(							self:   Tuple		):
											pass


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   List[str]		):
											pass


				@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''		)
				def     _A							(							self:   Any		):
											pass


				@unittest.skip('''model weights aren\'t tied in TimmBackbone.'''		)
				def     _A							(							self:   Tuple		):
											pass


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   Optional[int]		):
											pass


				@unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''		)
				def     _A							(							self:   Union[str, Any]		):
											pass


				@unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''		)
				def     _A							(							self:   Any		):
											pass


				@unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''		)
				def     _A							(							self:   Tuple		):
											pass


				@unittest.skip('''Safetensors is not supported by timm.'''		)
				def     _A							(							self:   Optional[int]		):
											pass


				@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''		)
				def     _A							(							self:   str		):
											pass


				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    inspect.signature(model.forward		)
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		SCREAMING_SNAKE_CASE_   	=    [*signature.parameters.keys()]

																		SCREAMING_SNAKE_CASE_   	=    ['''pixel_values''']
																		self.assertListEqual(arg_names[:1]		,					_lowerCamelCase		)


				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE_   	=    True
											SCREAMING_SNAKE_CASE_   	=    self.has_attentions

											# no need to test all models as different heads yield the same functionality
											SCREAMING_SNAKE_CASE_   	=    self.all_model_classes[0]
											SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
											model.to(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    self._prepare_for_class(_lowerCamelCase		,					_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    outputs[0][-1]

											# Encoder-/Decoder-only models
											SCREAMING_SNAKE_CASE_   	=    outputs.hidden_states[0]
											hidden_states.retain_grad()

											if self.has_attentions:
																		SCREAMING_SNAKE_CASE_   	=    outputs.attentions[0]
																		attentions.retain_grad()

											output.flatten()[0].backward(retain_graph=_lowerCamelCase		)

											self.assertIsNotNone(hidden_states.grad		)

											if self.has_attentions:
																		self.assertIsNotNone(attentions.grad		)





				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)

																		self.assertEqual(len(result.feature_maps		)		,					len(config.out_indices		)		)
																		self.assertEqual(len(model.channels		)		,					len(config.out_indices		)		)

																		# Check output of last stage is taken if out_features=None, out_indices=None
																		SCREAMING_SNAKE_CASE_   	=    copy.deepcopy(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    None
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)

																		self.assertEqual(len(result.feature_maps		)		,					1		)
																		self.assertEqual(len(model.channels		)		,					1		)

																		# Check backbone can be initialized with fresh weights
																		SCREAMING_SNAKE_CASE_   	=    copy.deepcopy(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    False
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)


