






import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VideoMAEConfig
from transformers.models.auto import get_values
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_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import (
					    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
					    VideoMAEForPreTraining,
					    VideoMAEForVideoClassification,
					    VideoMAEModel,
					)
					from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from transformers import VideoMAEImageProcessor
class      UpperCamelCase :







		"""simple docstring"""



		def __init__(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       int=1_3						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=1_0						,_SCREAMING_SNAKE_CASE		:       Dict=3						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=2						,_SCREAMING_SNAKE_CASE		:       Any=2						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=2						,_SCREAMING_SNAKE_CASE		:       List[Any]=True						,_SCREAMING_SNAKE_CASE		:       List[str]=True						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=3_2						,_SCREAMING_SNAKE_CASE		:       int=5						,_SCREAMING_SNAKE_CASE		:       Dict=4						,_SCREAMING_SNAKE_CASE		:       Tuple=3_7						,_SCREAMING_SNAKE_CASE		:       Any="gelu"						,_SCREAMING_SNAKE_CASE		:       List[str]=0.1						,_SCREAMING_SNAKE_CASE		:       List[str]=0.1						,_SCREAMING_SNAKE_CASE		:       Optional[int]=1_0						,_SCREAMING_SNAKE_CASE		:       List[str]=0.02						,_SCREAMING_SNAKE_CASE		:       Tuple=0.9						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]=None						,)    ->   Any:


						'''simple docstring'''
						A	 =      parent
						A	 =      batch_size
						A	 =      image_size
						A	 =      num_channels
						A	 =      patch_size
						A	 =      tubelet_size
						A	 =      num_frames
						A	 =      is_training
						A	 =      use_labels
						A	 =      hidden_size
						A	 =      num_hidden_layers
						A	 =      num_attention_heads
						A	 =      intermediate_size
						A	 =      hidden_act
						A	 =      hidden_dropout_prob
						A	 =      attention_probs_dropout_prob
						A	 =      type_sequence_label_size
						A	 =      initializer_range
						A	 =      mask_ratio
						A	 =      scope

						# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
						A	 =      (image_size // patch_size) ** 2
						A	 =      (num_frames // tubelet_size) * self.num_patches_per_frame

						# use this variable to define bool_masked_pos
						A	 =      int(mask_ratio * self.seq_length		)
		def       A(  self		:       Tuple		)    ->   str:


						'''simple docstring'''
						A	 =      floats_tensor(
						    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]		)

						A	 =      None
						if self.use_labels:
										A	 =      ids_tensor([self.batch_size]						,self.type_sequence_label_size		)

						A	 =      self.get_config()

						return config, pixel_values, labels
		def       A(  self		:       Any		)    ->   int:


						'''simple docstring'''
						return VideoMAEConfig(
						    image_size=self.image_size						,patch_size=self.patch_size						,num_channels=self.num_channels						,num_frames=self.num_frames						,tubelet_size=self.tubelet_size						,hidden_size=self.hidden_size						,num_hidden_layers=self.num_hidden_layers						,num_attention_heads=self.num_attention_heads						,intermediate_size=self.intermediate_size						,hidden_act=self.hidden_act						,hidden_dropout_prob=self.hidden_dropout_prob						,attention_probs_dropout_prob=self.attention_probs_dropout_prob						,is_decoder=_SCREAMING_SNAKE_CASE						,initializer_range=self.initializer_range						,)
		def       A(  self		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]		)    ->   Union[str, Any]:


						'''simple docstring'''
						A	 =      VideoMAEModel(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A	 =      model(_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)		)
		def       A(  self		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       int		)    ->   Dict:


						'''simple docstring'''
						A	 =      VideoMAEForPreTraining(_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						# important: each video needs to have the same number of masked patches
						# hence we define a single mask, which we then repeat for each example in the batch
						A	 =      torch.ones((self.num_masks,)		)
						A	 =      torch.cat([mask, torch.zeros(self.seq_length - mask.size(0		)		)]		)
						A	 =      mask.expand(self.batch_size						,-1		).bool()

						A	 =      model(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
						# model only returns predictions for masked patches
						A	 =      mask.sum().item()
						A	 =      3 * self.tubelet_size * self.patch_size**2
						self.parent.assertEqual(result.logits.shape						,(self.batch_size, num_masked_patches, decoder_num_labels)		)







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


						'''simple docstring'''
						A	 =      self.prepare_config_and_inputs()
						A ,		A ,		A	 =      config_and_inputs
						A	 =      {'pixel_values': pixel_values}
						return config, inputs_dict


@require_torch
class      UpperCamelCase (				snake_case__			,       snake_case__			,       unittest.TestCase ):







		"""simple docstring"""



		snake_case    =   (
		    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
		)
		snake_case    =   (
		    {"feature-extraction": VideoMAEModel, "video-classification": VideoMAEForVideoClassification}
		    if is_torch_available()
		    else {}
		)

		snake_case    =   False
		snake_case    =   False
		snake_case    =   False
		snake_case    =   False
		def       A(  self		:       Union[str, Any]		)    ->   List[Any]:


						'''simple docstring'''
						A	 =      VideoMAEModelTester(self		)
						A	 =      ConfigTester(self						,config_class=_SCREAMING_SNAKE_CASE						,has_text_modality=_SCREAMING_SNAKE_CASE						,hidden_size=3_7		)
		def       A(  self		:       str						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=False		)    ->   Dict:


						'''simple docstring'''
						A	 =      copy.deepcopy(_SCREAMING_SNAKE_CASE		)

						if model_class == VideoMAEForPreTraining:
										# important: each video needs to have the same number of masked patches
										# hence we define a single mask, which we then repeat for each example in the batch
										A	 =      torch.ones((self.model_tester.num_masks,)		)
										A	 =      torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0		)		)]		)
										A	 =      mask.expand(self.model_tester.batch_size						,-1		).bool()
										A	 =      bool_masked_pos.to(_SCREAMING_SNAKE_CASE		)

						if return_labels:
										if model_class in [
										    *get_values(_SCREAMING_SNAKE_CASE		),
										]:
														A	 =      torch.zeros(
														    self.model_tester.batch_size						,dtype=torch.long						,device=_SCREAMING_SNAKE_CASE		)

						return inputs_dict
		def       A(  self		:       int		)    ->   Optional[Any]:


						'''simple docstring'''
						self.config_tester.run_common_tests()
		@unittest.skip(reason='VideoMAE does not use inputs_embeds'		)
		def       A(  self		:       List[str]		)    ->   List[str]:


						'''simple docstring'''
						pass
		def       A(  self		:       Union[str, Any]		)    ->   Optional[Any]:


						'''simple docstring'''
						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										A	 =      model_class(_SCREAMING_SNAKE_CASE		)
										self.assertIsInstance(model.get_input_embeddings()						,(nn.Module)		)
										A	 =      model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE						,nn.Linear		)		)
		def       A(  self		:       Any		)    ->   List[str]:


						'''simple docstring'''
						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

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

										A	 =      ['pixel_values']
										self.assertListEqual(arg_names[:1]						,_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Dict		)    ->   List[Any]:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       List[str]		)    ->   Dict:


						'''simple docstring'''
						A	 =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_pretraining(*_SCREAMING_SNAKE_CASE		)
		@slow
		def       A(  self		:       int		)    ->   Dict:


						'''simple docstring'''
						for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										A	 =      VideoMAEModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       List[Any]		)    ->   Optional[int]:


						'''simple docstring'''
						if not self.has_attentions:
										pass

						else:
										A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()
										A	 =      True

										for model_class in self.all_model_classes:
														A	 =      self.model_tester.seq_length - self.model_tester.num_masks
														A	 =      (
														    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
														)

														A	 =      True
														A	 =      False
														A	 =      True
														A	 =      model_class(_SCREAMING_SNAKE_CASE		)
														model.to(_SCREAMING_SNAKE_CASE		)
														model.eval()
														with torch.no_grad():
																		A	 =      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)
														A	 =      outputs.attentions
														self.assertEqual(len(_SCREAMING_SNAKE_CASE		)						,self.model_tester.num_hidden_layers		)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														A	 =      True
														A	 =      model_class(_SCREAMING_SNAKE_CASE		)
														model.to(_SCREAMING_SNAKE_CASE		)
														model.eval()
														with torch.no_grad():
																		A	 =      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)
														A	 =      outputs.attentions
														self.assertEqual(len(_SCREAMING_SNAKE_CASE		)						,self.model_tester.num_hidden_layers		)

														self.assertListEqual(
														    list(attentions[0].shape[-3:]		)						,[self.model_tester.num_attention_heads, seq_len, seq_len]						,)
														A	 =      len(_SCREAMING_SNAKE_CASE		)

														# Check attention is always last and order is fine
														A	 =      True
														A	 =      True
														A	 =      model_class(_SCREAMING_SNAKE_CASE		)
														model.to(_SCREAMING_SNAKE_CASE		)
														model.eval()
														with torch.no_grad():
																		A	 =      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)

														self.assertEqual(out_len + 1						,len(_SCREAMING_SNAKE_CASE		)		)

														A	 =      outputs.attentions

														self.assertEqual(len(_SCREAMING_SNAKE_CASE		)						,self.model_tester.num_hidden_layers		)
														self.assertListEqual(
														    list(self_attentions[0].shape[-3:]		)						,[self.model_tester.num_attention_heads, seq_len, seq_len]						,)
		def       A(  self		:       Optional[Any]		)    ->   Dict:


						'''simple docstring'''
						def check_hidden_states_output(_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       int		):
										A	 =      model_class(_SCREAMING_SNAKE_CASE		)
										model.to(_SCREAMING_SNAKE_CASE		)
										model.eval()

										with torch.no_grad():
														A	 =      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)

										A	 =      outputs.hidden_states
										A	 =      self.model_tester.num_hidden_layers + 1
										self.assertEqual(len(_SCREAMING_SNAKE_CASE		)						,_SCREAMING_SNAKE_CASE		)

										A	 =      self.model_tester.seq_length - self.model_tester.num_masks
										A	 =      num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length

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

						A ,		A	 =      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										A	 =      True
										check_hidden_states_output(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										A	 =      True

										check_hidden_states_output(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)







		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'		)
		def       A(  self		:       Optional[int]		)    ->   Tuple:


						'''simple docstring'''
						pass







def      snake_case		(							):
				A	 =      hf_hub_download(
				    repo_id='hf-internal-testing/spaghetti-video',						filename='eating_spaghetti.npy',						repo_type='dataset'   )
				A	 =      np.load(UpperCAmelCase   )
				return list(UpperCAmelCase   )



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







		"""simple docstring"""



		@cached_property
		def       A(  self		:       Tuple		)    ->   int:


						'''simple docstring'''
						# logits were tested with a different mean and std, so we use the same here
						return (
						    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]						,image_std=[0.5, 0.5, 0.5]		)
						    if is_vision_available()
						    else None
						)
		@slow
		def       A(  self		:       str		)    ->   Union[str, Any]:


						'''simple docstring'''
						A	 =      VideoMAEForVideoClassification.from_pretrained('MCG-NJU/videomae-base-finetuned-kinetics'		).to(
						    _SCREAMING_SNAKE_CASE		)

						A	 =      self.default_image_processor
						A	 =      prepare_video()
						A	 =      image_processor(_SCREAMING_SNAKE_CASE						,return_tensors='pt'		).to(_SCREAMING_SNAKE_CASE		)

						# forward pass
						with torch.no_grad():
										A	 =      model(**_SCREAMING_SNAKE_CASE		)

						# verify the logits
						A	 =      torch.Size((1, 4_0_0)		)
						self.assertEqual(outputs.logits.shape						,_SCREAMING_SNAKE_CASE		)

						A	 =      torch.tensor([0.3669, -0.0688, -0.2421]		).to(_SCREAMING_SNAKE_CASE		)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]						,_SCREAMING_SNAKE_CASE						,atol=1E-4		)		)







		@slow
		def       A(  self		:       Dict		)    ->   Union[str, Any]:


						'''simple docstring'''
						A	 =      VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short'		).to(_SCREAMING_SNAKE_CASE		)

						A	 =      self.default_image_processor
						A	 =      prepare_video()
						A	 =      image_processor(_SCREAMING_SNAKE_CASE						,return_tensors='pt'		).to(_SCREAMING_SNAKE_CASE		)

						# add boolean mask, indicating which patches to mask
						A	 =      hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos'						,filename='bool_masked_pos.pt'		)
						A	 =      torch.load(_SCREAMING_SNAKE_CASE		)

						# forward pass
						with torch.no_grad():
										A	 =      model(**_SCREAMING_SNAKE_CASE		)

						# verify the logits
						A	 =      torch.Size([1, 1_4_0_8, 1_5_3_6]		)
						A	 =      torch.tensor(
						    [[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]						,device=_SCREAMING_SNAKE_CASE		)
						self.assertEqual(outputs.logits.shape						,_SCREAMING_SNAKE_CASE		)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]						,_SCREAMING_SNAKE_CASE						,atol=1E-4		)		)

						# verify the loss (`config.norm_pix_loss` = `True`)
						A	 =      torch.tensor([0.5142]						,device=_SCREAMING_SNAKE_CASE		)
						self.assertTrue(torch.allclose(outputs.loss						,_SCREAMING_SNAKE_CASE						,atol=1E-4		)		)

						# verify the loss (`config.norm_pix_loss` = `False`)
						A	 =      VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short'						,norm_pix_loss=_SCREAMING_SNAKE_CASE		).to(
						    _SCREAMING_SNAKE_CASE		)

						with torch.no_grad():
										A	 =      model(**_SCREAMING_SNAKE_CASE		)

						A	 =      torch.tensor(torch.tensor([0.6469]		)						,device=_SCREAMING_SNAKE_CASE		)
						self.assertTrue(torch.allclose(outputs.loss						,_SCREAMING_SNAKE_CASE						,atol=1E-4		)		)













import copy
import re
class      UpperCamelCase :







		"""simple docstring"""



		snake_case    =   "hp"
		snake_case    =   {}
		snake_case    =   None
		@classmethod
		def       A(  cls		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   int:


						'''simple docstring'''
						A	 =      prefix
						A	 =      defaults
						cls.build_naming_info()
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   Optional[Any]:


						'''simple docstring'''
						if len(_SCREAMING_SNAKE_CASE		) == 0:
										return ""
						A	 =      None
						if any(char.isdigit() for char in word		):
										raise Exception(f'Parameters should not contain numbers: \'{word}\' contains a number'		)
						if word in info["short_word"]:
										return info["short_word"][word]
						for prefix_len in range(1						,len(_SCREAMING_SNAKE_CASE		) + 1		):
										A	 =      word[:prefix_len]
										if prefix in info["reverse_short_word"]:
														continue
										else:
														A	 =      prefix
														break

						if short_word is None:
										# Paranoid fallback
										def int_to_alphabetic(_SCREAMING_SNAKE_CASE		:       Optional[int]		):
														A	 =      ''
														while integer != 0:
																		A	 =      chr(ord('A'		) + integer % 1_0		) + s
																		integer //= 1_0
														return s

										A	 =      0
										while True:
														A	 =      word + '#' + int_to_alphabetic(_SCREAMING_SNAKE_CASE		)
														if sword in info["reverse_short_word"]:
																		continue
														else:
																		A	 =      sword
																		break

						A	 =      short_word
						A	 =      word
						return short_word
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   int:


						'''simple docstring'''
						A	 =      param_name.split('_'		)

						A	 =      [TrialShortNamer.shortname_for_word(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		) for word in words]

						# We try to create a separatorless short name, but if there is a collision we have to fallback
						# to a separated short name
						A	 =      ['', '_']

						for separator in separators:
										A	 =      separator.join(_SCREAMING_SNAKE_CASE		)
										if shortname not in info["reverse_short_param"]:
														A	 =      shortname
														A	 =      param_name
														return shortname

						return param_name
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   List[str]:


						'''simple docstring'''
						A	 =      TrialShortNamer.shortname_for_key(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
						A	 =      short_name
						A	 =      param_name
		@classmethod
		def       A(  cls		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						if cls.NAMING_INFO is not None:
										return

						A	 =      {
						    'short_word': {},
						    'reverse_short_word': {},
						    'short_param': {},
						    'reverse_short_param': {},
						}

						A	 =      list(cls.DEFAULTS.keys()		)

						for k in field_keys:
										cls.add_new_param_name(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)

						A	 =      info
		@classmethod
		def       A(  cls		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str		)    ->   List[Any]:


						'''simple docstring'''
						cls.build_naming_info()
						assert cls.PREFIX is not None
						A	 =      [copy.copy(cls.PREFIX		)]

						for k, v in params.items():
										if k not in cls.DEFAULTS:
														raise Exception(f'You should provide a default value for the param name {k} with value {v}'		)
										if v == cls.DEFAULTS[k]:
														# The default value is not added to the name
														continue

										A	 =      cls.NAMING_INFO['short_param'][k]

										if isinstance(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		):
														A	 =      1 if v else 0

										A	 =      '' if isinstance(_SCREAMING_SNAKE_CASE						,(int, float)		) else '-'
										A	 =      f'{key}{sep}{v}'
										name.append(_SCREAMING_SNAKE_CASE		)

						return "_".join(_SCREAMING_SNAKE_CASE		)







		@classmethod
		def       A(  cls		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						A	 =      repr[len(cls.PREFIX		) + 1 :]
						if repr == "":
										A	 =      []
						else:
										A	 =      repr.split('_'		)

						A	 =      {}

						for value in values:
										if "-" in value:
														A ,		A	 =      value.split('-'		)
										else:
														A	 =      re.sub('[0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)
														A	 =      float(re.sub('[^0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)		)

										A	 =      cls.NAMING_INFO['reverse_short_param'][p_k]

										A	 =      p_v

						for k in cls.DEFAULTS:
										if k not in parameters:
														A	 =      cls.DEFAULTS[k]

						return parameters





