

'''simple docstring'''


import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import (
						    FocalNetBackbone,
						    FocalNetForImageClassification,
						    FocalNetForMaskedImageModeling,
						    FocalNetModel,
						)
						from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor



class 					lowercase						:


							def __init__(			self    ,			_snake_case    ,			_snake_case=13    ,			_snake_case=32    ,			_snake_case=2    ,			_snake_case=3    ,			_snake_case=16    ,			_snake_case=[32, 64, 128]    ,			_snake_case=[1, 2, 1]    ,			_snake_case=[2, 2, 4]    ,			_snake_case=2    ,			_snake_case=2.0    ,			_snake_case=True    ,			_snake_case=0.0    ,			_snake_case=0.0    ,			_snake_case=0.1    ,			_snake_case="gelu"    ,			_snake_case=False    ,			_snake_case=True    ,			_snake_case=0.02    ,			_snake_case=1e-5    ,			_snake_case=True    ,			_snake_case=None    ,			_snake_case=True    ,			_snake_case=10    ,			_snake_case=8    ,			_snake_case=["stage1", "stage2"]    ,			_snake_case=[1, 2]    ,			)							->				List[str]:
								UpperCAmelCase_		:      Dict       	=					parent
								UpperCAmelCase_		:      List[str]       	=					batch_size
								UpperCAmelCase_		:      Tuple       	=					image_size
								UpperCAmelCase_		:      Union[str, Any]       	=					patch_size
								UpperCAmelCase_		:      List[Any]       	=					num_channels
								UpperCAmelCase_		:      Optional[Any]       	=					embed_dim
								UpperCAmelCase_		:      str       	=					hidden_sizes
								UpperCAmelCase_		:      Any       	=					depths
								UpperCAmelCase_		:      Optional[int]       	=					num_heads
								UpperCAmelCase_		:      Optional[Any]       	=					window_size
								UpperCAmelCase_		:      List[str]       	=					mlp_ratio
								UpperCAmelCase_		:      int       	=					qkv_bias
								UpperCAmelCase_		:      Union[str, Any]       	=					hidden_dropout_prob
								UpperCAmelCase_		:      Optional[int]       	=					attention_probs_dropout_prob
								UpperCAmelCase_		:      Dict       	=					drop_path_rate
								UpperCAmelCase_		:      Any       	=					hidden_act
								UpperCAmelCase_		:      Optional[Any]       	=					use_absolute_embeddings
								UpperCAmelCase_		:      int       	=					patch_norm
								UpperCAmelCase_		:      int       	=					layer_norm_eps
								UpperCAmelCase_		:      Union[str, Any]       	=					initializer_range
								UpperCAmelCase_		:      List[Any]       	=					is_training
								UpperCAmelCase_		:      Union[str, Any]       	=					scope
								UpperCAmelCase_		:      Any       	=					use_labels
								UpperCAmelCase_		:      Optional[Any]       	=					type_sequence_label_size
								UpperCAmelCase_		:      Optional[int]       	=					encoder_stride
								UpperCAmelCase_		:      Any       	=					out_features
								UpperCAmelCase_		:      Any       	=					out_indices


							def 						_snake_case							(			self)							->				int:
								UpperCAmelCase_		:      Any       	=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

								UpperCAmelCase_		:      Dict       	=					None
								if self.use_labels:
									UpperCAmelCase_		:      Optional[int]       	=					ids_tensor([self.batch_size]    ,			self.type_sequence_label_size)

								UpperCAmelCase_		:      Union[str, Any]       	=					self.get_config()

								return config, pixel_values, labels


							def 						_snake_case							(			self)							->				Optional[Any]:
								return FocalNetConfig(
								    image_size=self.image_size    ,			patch_size=self.patch_size    ,			num_channels=self.num_channels    ,			embed_dim=self.embed_dim    ,			hidden_sizes=self.hidden_sizes    ,			depths=self.depths    ,			num_heads=self.num_heads    ,			window_size=self.window_size    ,			mlp_ratio=self.mlp_ratio    ,			qkv_bias=self.qkv_bias    ,			hidden_dropout_prob=self.hidden_dropout_prob    ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,			drop_path_rate=self.drop_path_rate    ,			hidden_act=self.hidden_act    ,			use_absolute_embeddings=self.use_absolute_embeddings    ,			path_norm=self.patch_norm    ,			layer_norm_eps=self.layer_norm_eps    ,			initializer_range=self.initializer_range    ,			encoder_stride=self.encoder_stride    ,			out_features=self.out_features    ,			out_indices=self.out_indices    ,			)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      Tuple       	=					FocalNetModel(config=_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      Optional[int]       	=					model(_snake_case)

								UpperCAmelCase_		:      Optional[Any]       	=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
								UpperCAmelCase_		:      Dict       	=					int(config.embed_dim * 2 ** (len(config.depths) - 1))

								self.parent.assertEqual(result.last_hidden_state.shape    ,			(self.batch_size, expected_seq_len, expected_dim))


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				Union[str, Any]:
								UpperCAmelCase_		:      Union[str, Any]       	=					FocalNetBackbone(config=_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      Union[str, Any]       	=					model(_snake_case)

								# verify feature maps
								self.parent.assertEqual(len(result.feature_maps)    ,			len(config.out_features))
								self.parent.assertListEqual(list(result.feature_maps[0].shape)    ,			[self.batch_size, self.image_size, 8, 8])

								# verify channels
								self.parent.assertEqual(len(model.channels)    ,			len(config.out_features))
								self.parent.assertListEqual(model.channels    ,			config.hidden_sizes[:-1])

								# verify backbone works with out_features=None
								UpperCAmelCase_		:      Tuple       	=					None
								UpperCAmelCase_		:      Union[str, Any]       	=					FocalNetBackbone(config=_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      Optional[int]       	=					model(_snake_case)

								# verify feature maps
								self.parent.assertEqual(len(result.feature_maps)    ,			1)
								self.parent.assertListEqual(list(result.feature_maps[0].shape)    ,			[self.batch_size, self.image_size * 2, 4, 4])

								# verify channels
								self.parent.assertEqual(len(model.channels)    ,			1)
								self.parent.assertListEqual(model.channels    ,			[config.hidden_sizes[-1]])


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				Any:
								UpperCAmelCase_		:      int       	=					FocalNetForMaskedImageModeling(config=_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      Optional[Any]       	=					model(_snake_case)
								self.parent.assertEqual(
								    result.reconstruction.shape    ,			(self.batch_size, self.num_channels, self.image_size, self.image_size))

								# test greyscale images
								UpperCAmelCase_		:      int       	=					1
								UpperCAmelCase_		:      List[Any]       	=					FocalNetForMaskedImageModeling(_snake_case)
								model.to(_snake_case)
								model.eval()

								UpperCAmelCase_		:      List[Any]       	=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
								UpperCAmelCase_		:      Optional[int]       	=					model(_snake_case)
								self.parent.assertEqual(result.reconstruction.shape    ,			(self.batch_size, 1, self.image_size, self.image_size))


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				int:
								UpperCAmelCase_		:      str       	=					self.type_sequence_label_size
								UpperCAmelCase_		:      str       	=					FocalNetForImageClassification(_snake_case)
								model.to(_snake_case)
								model.eval()
								UpperCAmelCase_		:      List[Any]       	=					model(_snake_case    ,			labels=_snake_case)
								self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size))

								# test greyscale images
								UpperCAmelCase_		:      Tuple       	=					1
								UpperCAmelCase_		:      int       	=					FocalNetForImageClassification(_snake_case)
								model.to(_snake_case)
								model.eval()

								UpperCAmelCase_		:      Union[str, Any]       	=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
								UpperCAmelCase_		:      Optional[int]       	=					model(_snake_case)
								self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size))





							def 						_snake_case							(			self)							->				Optional[int]:
								UpperCAmelCase_		:      int       	=					self.prepare_config_and_inputs()

								UpperCAmelCase_	,    UpperCAmelCase_	,    UpperCAmelCase_		:      Union[str, Any]       	=					config_and_inputs
								UpperCAmelCase_		:      List[Any]       	=					{'pixel_values': pixel_values}
								return config, inputs_dict



@require_torch
class 					lowercase						(  a_,					a_,					unittest.TestCase ):
							_lowerCamelCase		:      Any=   (
							    (
							        FocalNetModel,
							        FocalNetForImageClassification,
							        FocalNetForMaskedImageModeling,
							        FocalNetBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							_lowerCamelCase		:      int=   (
							    {"feature-extraction": FocalNetModel, "image-classification": FocalNetForImageClassification}
							    if is_torch_available()
							    else {}
							)
							_lowerCamelCase		:      int=   False

							_lowerCamelCase		:      Any=   False
							_lowerCamelCase		:      Optional[Any]=   False
							_lowerCamelCase		:      Optional[Any]=   False
							_lowerCamelCase		:      Any=   False


							def 						_snake_case							(			self)							->				List[str]:
								UpperCAmelCase_		:      Union[str, Any]       	=					FocalNetModelTester(self)
								UpperCAmelCase_		:      Dict       	=					ConfigTester(self    ,			config_class=_snake_case    ,			embed_dim=37    ,			has_text_modality=_snake_case)


							def 						_snake_case							(			self)							->				List[str]:
								self.create_and_test_config_common_properties()
								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 						_snake_case							(			self)							->				str:
								return


							def 						_snake_case							(			self)							->				int:
								UpperCAmelCase_		:      List[Any]       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case)


							def 						_snake_case							(			self)							->				List[str]:
								UpperCAmelCase_		:      Union[str, Any]       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*_snake_case)


							def 						_snake_case							(			self)							->				List[Any]:
								UpperCAmelCase_		:      Tuple       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*_snake_case)


							def 						_snake_case							(			self)							->				Any:
								UpperCAmelCase_		:      Optional[int]       	=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case)


							@unittest.skip(reason='FocalNet does not use inputs_embeds')
							def 						_snake_case							(			self)							->				int:
								pass


							@unittest.skip(reason='FocalNet does not use feedforward chunking')
							def 						_snake_case							(			self)							->				Optional[int]:
								pass


							def 						_snake_case							(			self)							->				Any:
								UpperCAmelCase_	,    UpperCAmelCase_		:      Dict       	=					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes[:-1]:
									UpperCAmelCase_		:      Any       	=					model_class(_snake_case)
									self.assertIsInstance(model.get_input_embeddings()    ,			(nn.Module))
									UpperCAmelCase_		:      Optional[int]       	=					model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(_snake_case    ,			nn.Linear))


							def 						_snake_case							(			self)							->				str:
								UpperCAmelCase_	,    UpperCAmelCase_		:      Dict       	=					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes[:-1]:
									UpperCAmelCase_		:      Optional[Any]       	=					model_class(_snake_case)
									UpperCAmelCase_		:      Dict       	=					inspect.signature(model.forward)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									UpperCAmelCase_		:      Optional[Any]       	=					[*signature.parameters.keys()]

									UpperCAmelCase_		:      Tuple       	=					['pixel_values']
									self.assertListEqual(arg_names[:1]    ,			_snake_case)


							def 						_snake_case							(			self    ,			_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case)							->				List[str]:
								UpperCAmelCase_		:      str       	=					model_class(_snake_case)
								model.to(_snake_case)
								model.eval()

								with torch.no_grad():
									UpperCAmelCase_		:      int       	=					model(**self._prepare_for_class(_snake_case    ,			_snake_case))

								UpperCAmelCase_		:      List[Any]       	=					outputs.hidden_states

								UpperCAmelCase_		:      Any       	=					getattr(
								    self.model_tester    ,			'expected_num_hidden_layers'    ,			len(self.model_tester.depths) + 1)
								self.assertEqual(len(_snake_case)    ,			_snake_case)

								# FocalNet has a different seq_length
								UpperCAmelCase_		:      Tuple       	=					(
								    config.patch_size
								    if isinstance(config.patch_size    ,			collections.abc.Iterable)
								    else (config.patch_size, config.patch_size)
								)

								UpperCAmelCase_		:      Optional[Any]       	=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

								self.assertListEqual(
								    list(hidden_states[0].shape[-2:])    ,			[num_patches, self.model_tester.embed_dim]    ,			)

								UpperCAmelCase_		:      Any       	=					outputs.reshaped_hidden_states
								self.assertEqual(len(_snake_case)    ,			_snake_case)

								UpperCAmelCase_	,    UpperCAmelCase_	,    UpperCAmelCase_	,    UpperCAmelCase_		:      Union[str, Any]       	=					reshaped_hidden_states[0].shape
								UpperCAmelCase_		:      Optional[int]       	=					(
								    reshaped_hidden_states[0].view(_snake_case    ,			_snake_case    ,			height * width).permute(0    ,			2    ,			1)
								)
								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-2:])    ,			[num_patches, self.model_tester.embed_dim]    ,			)


							def 						_snake_case							(			self)							->				Tuple:
								UpperCAmelCase_	,    UpperCAmelCase_		:      Any       	=					self.model_tester.prepare_config_and_inputs_for_common()

								UpperCAmelCase_		:      Union[str, Any]       	=					(
								    self.model_tester.image_size
								    if isinstance(self.model_tester.image_size    ,			collections.abc.Iterable)
								    else (self.model_tester.image_size, self.model_tester.image_size)
								)

								for model_class in self.all_model_classes[:-1]:
									UpperCAmelCase_		:      List[str]       	=					True
									self.check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									UpperCAmelCase_		:      List[str]       	=					True

									self.check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case)


							def 						_snake_case							(			self)							->				int:
								UpperCAmelCase_	,    UpperCAmelCase_		:      Dict       	=					self.model_tester.prepare_config_and_inputs_for_common()
								UpperCAmelCase_		:      Optional[Any]       	=					3

								UpperCAmelCase_		:      Tuple       	=					(
								    self.model_tester.image_size
								    if isinstance(self.model_tester.image_size    ,			collections.abc.Iterable)
								    else (self.model_tester.image_size, self.model_tester.image_size)
								)
								UpperCAmelCase_		:      str       	=					(
								    config.patch_size
								    if isinstance(config.patch_size    ,			collections.abc.Iterable)
								    else (config.patch_size, config.patch_size)
								)

								UpperCAmelCase_		:      Dict       	=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								UpperCAmelCase_		:      Optional[Any]       	=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes[:-1]:
									UpperCAmelCase_		:      List[str]       	=					True
									self.check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case    ,			(padded_height, padded_width))

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									UpperCAmelCase_		:      List[str]       	=					True
									self.check_hidden_states_output(_snake_case    ,			_snake_case    ,			_snake_case    ,			(padded_height, padded_width))


							@slow
							def 						_snake_case							(			self)							->				Tuple:
								for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCAmelCase_		:      int       	=					FocalNetModel.from_pretrained(_snake_case)
									self.assertIsNotNone(_snake_case)





							def 						_snake_case							(			self)							->				List[str]:
								UpperCAmelCase_	,    UpperCAmelCase_		:      Optional[int]       	=					self.model_tester.prepare_config_and_inputs_for_common()

								UpperCAmelCase_		:      Optional[int]       	=					_config_zero_init(_snake_case)
								for model_class in self.all_model_classes:
									UpperCAmelCase_		:      int       	=					model_class(config=_snake_case)
									for name, param in model.named_parameters():
										if "embeddings" not in name and param.requires_grad:
											self.assertIn(
											    ((param.data.mean() * 1e9).round() / 1e9).item()    ,			[0.0, 1.0]    ,			msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""    ,			)



@require_vision
@require_torch
class 					lowercase						(  unittest.TestCase ):


							@cached_property
							def 						_snake_case							(			self)							->				List[Any]:
								# TODO update organization
								return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny') if is_vision_available() else None





							@slow
							def 						_snake_case							(			self)							->				Optional[int]:
								UpperCAmelCase_		:      Optional[Any]       	=					FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny').to(_snake_case)
								UpperCAmelCase_		:      List[Any]       	=					self.default_image_processor

								UpperCAmelCase_		:      Optional[int]       	=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
								UpperCAmelCase_		:      Any       	=					image_processor(images=_snake_case    ,			return_tensors='pt').to(_snake_case)

								# forward pass
								with torch.no_grad():
									UpperCAmelCase_		:      Any       	=					model(**_snake_case)

								# verify the logits
								UpperCAmelCase_		:      Dict       	=					torch.Size((1, 1000))
								self.assertEqual(outputs.logits.shape    ,			_snake_case)
								UpperCAmelCase_		:      List[Any]       	=					torch.tensor([0.2_166, -0.4_368, 0.2_191]).to(_snake_case)
								self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,			_snake_case    ,			atol=1e-4))
								self.assertTrue(outputs.logits.argmax(dim=-1).item()    ,			281)



@require_torch
class 					lowercase						(  a_,					unittest.TestCase ):
							_lowerCamelCase		:      List[Any]=   (FocalNetBackbone,) if is_torch_available() else ()
							_lowerCamelCase		:      List[Any]=   FocalNetConfig

							_lowerCamelCase		:      List[str]=   False


							def 						_snake_case							(			self)							->				str:
								UpperCAmelCase_		:      Optional[Any]       	=					FocalNetModelTester(self)









'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__										= logging.get_logger(__name__)

lowerCAmelCase__										= {
    "tanreinama/GPTSAN-2.8B-spout_is_uniform": (
        "https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json"
    ),
}



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      Any=   "gptsan-japanese"
							_lowerCamelCase		:      List[Any]=   [
							    "past_key_values",
							]
							_lowerCamelCase		:      Tuple=   {
							    "hidden_size": "d_model",
							    "num_attention_heads": "num_heads",
							    "num_hidden_layers": "num_layers",
							}


							def __init__(			self    ,			_snake_case=3_6000    ,			_snake_case=1280    ,			_snake_case=1024    ,			_snake_case=8192    ,			_snake_case=4096    ,			_snake_case=128    ,			_snake_case=10    ,			_snake_case=0    ,			_snake_case=16    ,			_snake_case=16    ,			_snake_case=128    ,			_snake_case=0.0    ,			_snake_case=1e-5    ,			_snake_case=False    ,			_snake_case=0.0    ,			_snake_case="float32"    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=False    ,			_snake_case=0.002    ,			_snake_case=False    ,			_snake_case=True    ,			_snake_case=3_5998    ,			_snake_case=3_5995    ,			_snake_case=3_5999    ,			**_snake_case    ,			)							->				Optional[int]:
								UpperCAmelCase_		:      Dict       	=					vocab_size
								UpperCAmelCase_		:      Optional[int]       	=					max_position_embeddings
								UpperCAmelCase_		:      Any       	=					d_model
								UpperCAmelCase_		:      int       	=					d_ff
								UpperCAmelCase_		:      Tuple       	=					d_ext
								UpperCAmelCase_		:      Tuple       	=					d_spout
								UpperCAmelCase_		:      List[Any]       	=					num_switch_layers
								UpperCAmelCase_		:      Tuple       	=					num_ext_layers
								UpperCAmelCase_		:      Optional[int]       	=					num_switch_layers + num_ext_layers
								UpperCAmelCase_		:      Tuple       	=					num_heads
								UpperCAmelCase_		:      List[str]       	=					num_experts
								UpperCAmelCase_		:      List[str]       	=					expert_capacity
								UpperCAmelCase_		:      Optional[int]       	=					dropout_rate
								UpperCAmelCase_		:      List[Any]       	=					layer_norm_epsilon
								UpperCAmelCase_		:      Any       	=					router_bias
								UpperCAmelCase_		:      Optional[Any]       	=					router_jitter_noise
								UpperCAmelCase_		:      str       	=					router_dtype
								UpperCAmelCase_		:      List[str]       	=					router_ignore_padding_tokens
								UpperCAmelCase_		:      Optional[int]       	=					output_hidden_states
								UpperCAmelCase_		:      Union[str, Any]       	=					output_attentions
								UpperCAmelCase_		:      Optional[int]       	=					initializer_factor
								UpperCAmelCase_		:      Optional[int]       	=					output_router_logits
								UpperCAmelCase_		:      List[str]       	=					use_cache

								super().__init__(
								    separator_token_id=_snake_case    ,			pad_token_id=_snake_case    ,			eos_token_id=_snake_case    ,			**_snake_case    ,			)






