





"""simple docstring"""






import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    FalconForCausalLM,
		    FalconForQuestionAnswering,
		    FalconForSequenceClassification,
		    FalconForTokenClassification,
		    FalconModel,
		)




class 				__lowercase			:







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase	,			_UpperCAmelCase=3	,			_UpperCAmelCase=7	,			_UpperCAmelCase=True	,			_UpperCAmelCase=True	,			_UpperCAmelCase=False	,			_UpperCAmelCase=True	,			_UpperCAmelCase=99	,			_UpperCAmelCase=32	,			_UpperCAmelCase=5	,			_UpperCAmelCase=4	,			_UpperCAmelCase=37	,			_UpperCAmelCase="gelu"	,			_UpperCAmelCase=0.1	,			_UpperCAmelCase=0.1	,			_UpperCAmelCase=512	,			_UpperCAmelCase=16	,			_UpperCAmelCase=2	,			_UpperCAmelCase=0.0_2	,			_UpperCAmelCase=3	,			_UpperCAmelCase=4	,			_UpperCAmelCase=None	,			):
									__a :						Union[str, Any]			       =  parent
									__a :						List[Any]			       =  batch_size
									__a :						Optional[int]			       =  seq_length
									__a :						Tuple			       =  is_training
									__a :						Optional[int]			       =  use_input_mask
									__a :						Optional[Any]			       =  use_token_type_ids
									__a :						List[Any]			       =  use_labels
									__a :						Any			       =  vocab_size
									__a :						int			       =  hidden_size
									__a :						Any			       =  num_hidden_layers
									__a :						Optional[Any]			       =  num_attention_heads
									__a :						str			       =  intermediate_size
									__a :						Dict			       =  hidden_act
									__a :						List[str]			       =  hidden_dropout_prob
									__a :						Any			       =  attention_probs_dropout_prob
									__a :						List[Any]			       =  max_position_embeddings
									__a :						str			       =  type_vocab_size
									__a :						Optional[int]			       =  type_sequence_label_size
									__a :						int			       =  initializer_range
									__a :						List[str]			       =  num_labels
									__a :						Dict			       =  num_choices
									__a :						Union[str, Any]			       =  scope







					def  _lowerCamelCase		(						self     ):
									__a :						str			       =  ids_tensor([self.batch_size, self.seq_length]	,			self.vocab_size     )

									__a :						List[str]			       =  None
									if self.use_input_mask:
													__a :						List[Any]			       =  random_attention_mask([self.batch_size, self.seq_length]     )

									__a :						List[Any]			       =  None

									__a :						Dict			       =  None
									__a :						str			       =  None
									__a :						Any			       =  None
									if self.use_labels:
													__a :						List[str]			       =  ids_tensor([self.batch_size]	,			self.type_sequence_label_size     )
													__a :						int			       =  ids_tensor([self.batch_size, self.seq_length]	,			self.num_labels     )
													__a :						Any			       =  ids_tensor([self.batch_size]	,			self.num_choices     )

									__a :						Optional[Any]			       =  self.get_config()

									return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







					def  _lowerCamelCase		(						self     ):
									return FalconConfig(
									    vocab_size=self.vocab_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	,			max_position_embeddings=self.max_position_embeddings	,			type_vocab_size=self.type_vocab_size	,			is_decoder=_UpperCAmelCase	,			initializer_range=self.initializer_range	,			pad_token_id=1	,			new_decoder_architecture=_UpperCAmelCase	,			)







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Union[str, Any]			       =  FalconModel(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						Dict			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase     )
									__a :						List[str]			       =  model(_UpperCAmelCase     )
									self.parent.assertEqual(result.last_hidden_state.shape	,			(self.batch_size, self.seq_length, self.hidden_size)     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			):
									__a :						Optional[int]			       =  True
									__a :						Tuple			       =  FalconModel(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						List[str]			       =  model(
									    _UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			encoder_hidden_states=_UpperCAmelCase	,			encoder_attention_mask=_UpperCAmelCase	,			)
									__a :						Any			       =  model(
									    _UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			encoder_hidden_states=_UpperCAmelCase	,			)
									__a :						str			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase     )
									self.parent.assertEqual(result.last_hidden_state.shape	,			(self.batch_size, self.seq_length, self.hidden_size)     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			):
									__a :						Optional[Any]			       =  FalconForCausalLM(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						Any			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			labels=_UpperCAmelCase     )
									self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.seq_length, self.vocab_size)     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			):
									__a :						Dict			       =  True
									__a :						List[Any]			       =  True
									__a :						str			       =  FalconForCausalLM(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()

									# first forward pass
									__a :						int			       =  model(
									    _UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			encoder_hidden_states=_UpperCAmelCase	,			encoder_attention_mask=_UpperCAmelCase	,			use_cache=_UpperCAmelCase	,			)
									__a :						Any			       =  outputs.past_key_values

									# create hypothetical multiple next token and extent to next_input_ids
									__a :						Union[str, Any]			       =  ids_tensor((self.batch_size, 3)	,			config.vocab_size     )
									__a :						Dict			       =  ids_tensor((self.batch_size, 3)	,			vocab_size=2     )

									# append to next input_ids and
									__a :						Tuple			       =  torch.cat([input_ids, next_tokens]	,			dim=-1     )
									__a :						int			       =  torch.cat([input_mask, next_mask]	,			dim=-1     )

									__a :						List[Any]			       =  model(
									    _UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			encoder_hidden_states=_UpperCAmelCase	,			encoder_attention_mask=_UpperCAmelCase	,			output_hidden_states=_UpperCAmelCase	,			)['''hidden_states'''][0]
									__a :						Tuple			       =  model(
									    _UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			encoder_hidden_states=_UpperCAmelCase	,			encoder_attention_mask=_UpperCAmelCase	,			past_key_values=_UpperCAmelCase	,			output_hidden_states=_UpperCAmelCase	,			)['''hidden_states'''][0]

									# select random slice
									__a :						Optional[Any]			       =  ids_tensor((1,)	,			output_from_past.shape[-1]     ).item()
									__a :						List[Any]			       =  output_from_no_past[:, -3:, random_slice_idx].detach()
									__a :						Optional[int]			       =  output_from_past[:, :, random_slice_idx].detach()

									self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]     )

									# test that outputs are equal for slice
									self.parent.assertTrue(torch.allclose(_UpperCAmelCase	,			_UpperCAmelCase	,			atol=1e-3     )     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  self.prepare_config_and_inputs()
									(
									    (
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						
									) :						Union[str, Any]			       =  config_and_inputs
									__a :						Dict			       =  {'''input_ids''': input_ids, '''attention_mask''': input_mask}
									return config, inputs_dict






@require_torch
class 				__lowercase			(			_UpperCamelCase   ,      _UpperCamelCase   ,      _UpperCamelCase   ,      unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  (
					    (
					        FalconModel,
					        FalconForCausalLM,
					        FalconForSequenceClassification,
					        FalconForTokenClassification,
					        FalconForQuestionAnswering,
					    )
					    if is_torch_available()
					    else ()
					)
					__lowerCAmelCase  =  (FalconForCausalLM,) if is_torch_available() else ()
					__lowerCAmelCase  =  (
					    {
					        '''feature-extraction''': FalconModel,
					        '''text-classification''': FalconForSequenceClassification,
					        '''text-generation''': FalconForCausalLM,
					        '''question-answering''': FalconForQuestionAnswering,
					        '''token-classification''': FalconForTokenClassification,
					        '''zero-shot''': FalconForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					__lowerCAmelCase  =  False
					__lowerCAmelCase  =  False







					def  _lowerCamelCase		(						self     ):
									__a :						Optional[Any]			       =  FalconModelTester(self     )
									__a :						int			       =  ConfigTester(self	,			config_class=_UpperCAmelCase	,			hidden_size=37     )







					def  _lowerCamelCase		(						self     ):
									self.config_tester.run_common_tests()







					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						*__a :						str			       =  self.model_tester.prepare_config_and_inputs()
									for alibi in [True, False]:
													__a :						Optional[int]			       =  alibi
													self.model_tester.create_and_check_model(_UpperCAmelCase	,			*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						Tuple			       =  self.model_tester.prepare_config_and_inputs_for_common()
									__a :						Dict			       =  3
									__a :						int			       =  input_dict['''input_ids''']
									__a :						Dict			       =  input_ids.ne(1     ).to(_UpperCAmelCase     )
									__a :						int			       =  ids_tensor([self.model_tester.batch_size]	,			self.model_tester.type_sequence_label_size     )
									__a :						List[str]			       =  FalconForSequenceClassification(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						List[str]			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			labels=_UpperCAmelCase     )
									self.assertEqual(result.logits.shape	,			(self.model_tester.batch_size, self.model_tester.num_labels)     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						List[Any]			       =  self.model_tester.prepare_config_and_inputs_for_common()
									__a :						Optional[Any]			       =  3
									__a :						str			       =  '''single_label_classification'''
									__a :						str			       =  input_dict['''input_ids''']
									__a :						Optional[int]			       =  input_ids.ne(1     ).to(_UpperCAmelCase     )
									__a :						Any			       =  ids_tensor([self.model_tester.batch_size]	,			self.model_tester.type_sequence_label_size     )
									__a :						Union[str, Any]			       =  FalconForSequenceClassification(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						List[Any]			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			labels=_UpperCAmelCase     )
									self.assertEqual(result.logits.shape	,			(self.model_tester.batch_size, self.model_tester.num_labels)     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						List[Any]			       =  self.model_tester.prepare_config_and_inputs_for_common()
									__a :						Optional[Any]			       =  input_dict['''input_ids''']
									__a :						int			       =  FalconForCausalLM(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						Tuple			       =  model(_UpperCAmelCase	,			use_cache=_UpperCAmelCase     )
									__a :						List[str]			       =  input_ids.shape[0]
									__a :						str			       =  model._convert_to_rw_cache(result.past_key_values     )
									__a :						int			       =  model._convert_cache_to_standard_format(_UpperCAmelCase	,			_UpperCAmelCase     )
									for layer in range(len(_UpperCAmelCase     )     ):
													for tensor_idx in range(2     ):
																	self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3     )
																	self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4     )
																	self.assertTrue(
																	    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]     )     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						Tuple			       =  self.model_tester.prepare_config_and_inputs_for_common()
									__a :						Union[str, Any]			       =  3
									__a :						List[str]			       =  '''multi_label_classification'''
									__a :						List[str]			       =  input_dict['''input_ids''']
									__a :						Optional[int]			       =  input_ids.ne(1     ).to(_UpperCAmelCase     )
									__a :						List[str]			       =  ids_tensor(
									    [self.model_tester.batch_size, config.num_labels]	,			self.model_tester.type_sequence_label_size     ).to(torch.float     )
									__a :						Optional[Any]			       =  FalconForSequenceClassification(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						Dict			       =  model(_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			labels=_UpperCAmelCase     )
									self.assertEqual(result.logits.shape	,			(self.model_tester.batch_size, self.model_tester.num_labels)     )







					def  _lowerCamelCase		(						self     ):
									# Falcon can have different numbers of KV-heads than the number of query heads, so we need
									# to override this test to use the right head counts.
									for model_class in self.all_generative_model_classes:
													__a       ,						__a :						Optional[int]			       =  self.model_tester.prepare_config_and_inputs_for_common()

													# If it doesn't support cache, pass the test
													if not hasattr(_UpperCAmelCase	,			'''use_cache'''     ):
																	return

													__a :						Optional[int]			       =  model_class(_UpperCAmelCase     ).to(_UpperCAmelCase     )
													if "use_cache" not in inputs:
																	__a :						Optional[int]			       =  True
													__a :						Dict			       =  model(**_UpperCAmelCase     )

													# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
													if "past_key_values" not in outputs:
																	return

													__a :						str			       =  (
													    getattr(_UpperCAmelCase	,			'''decoder_layers'''	,			_UpperCAmelCase     )
													    or getattr(_UpperCAmelCase	,			'''num_decoder_layers'''	,			_UpperCAmelCase     )
													    or config.num_hidden_layers
													)
													__a :						int			       =  getattr(_UpperCAmelCase	,			'''num_kv_heads'''	,			config.num_attention_heads     )
													__a :						Optional[int]			       =  getattr(_UpperCAmelCase	,			'''d_model'''	,			config.hidden_size     )
													__a :						List[Any]			       =  embed_dim // num_attention_heads

													__a :						Any			       =  outputs['''past_key_values''']
													self.assertEqual(len(_UpperCAmelCase     )	,			_UpperCAmelCase     )

													__a       ,						__a :						List[str]			       =  inputs['''input_ids'''].shape
													for i in range(_UpperCAmelCase     ):
																	if config.new_decoder_architecture:
																					__a :						str			       =  config.num_attention_heads
																	elif config.multi_query:
																					__a :						Optional[int]			       =  1
																	self.assertEqual(len(past_kv[0]     )	,			2     )  # K V for the decoder = 2
																	self.assertEqual(
																	    past_kv[i][0].shape	,			(batch_size, num_attention_heads, seq_length, per_head_embed_dim)     )
																	self.assertEqual(
																	    past_kv[i][1].shape	,			(batch_size, num_attention_heads, seq_length, per_head_embed_dim)     )






@require_torch
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					@slow
					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b'''     )
									__a :						List[Any]			       =  FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b'''     )
									model.eval()
									model.to(_UpperCAmelCase     )
									__a :						Union[str, Any]			       =  tokenizer('''My favorite food is'''	,			return_tensors='''pt'''     ).to(_UpperCAmelCase     )

									__a :						str			       =  (
									    '''My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'''
									)

									__a :						int			       =  model.generate(**_UpperCAmelCase	,			do_sample=_UpperCAmelCase	,			max_new_tokens=19     )
									__a :						str			       =  tokenizer.batch_decode(_UpperCAmelCase     )[0]

									self.assertEqual(_UpperCAmelCase	,			_UpperCAmelCase     )







					@slow
					def  _lowerCamelCase		(						self     ):
									# The big models are way too big for the CI, so we use tiny random models that resemble their
									# architectures but with much smaller and fewer layers
									for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
													__a :						Union[str, Any]			       =  AutoTokenizer.from_pretrained(_UpperCAmelCase     )
													__a :						List[str]			       =  FalconForCausalLM.from_pretrained(_UpperCAmelCase     )
													model.eval()
													model.to(_UpperCAmelCase     )
													__a :						str			       =  tokenizer('''My favorite food is'''	,			return_tensors='''pt'''     ).to(_UpperCAmelCase     )

													# We just test that these run without errors - the models are randomly initialized
													# and so the actual text outputs will be garbage
													model.generate(**_UpperCAmelCase	,			do_sample=_UpperCAmelCase	,			max_new_tokens=4     )
													model.generate(**_UpperCAmelCase	,			do_sample=_UpperCAmelCase	,			max_new_tokens=4     )
													model.generate(**_UpperCAmelCase	,			num_beams=2	,			max_new_tokens=4     )







					@slow
					def  _lowerCamelCase		(						self     ):
									# The big models are way too big for the CI, so we use tiny random models that resemble their
									# architectures but with much smaller and fewer layers
									with torch.no_grad():
													for repo in [
													    "Rocketknight1/falcon-rw-1b",
													    "Rocketknight1/tiny-random-falcon-7b",
													    "Rocketknight1/tiny-random-falcon-40b",
													]:
																	__a :						Any			       =  AutoTokenizer.from_pretrained(_UpperCAmelCase     )
																	__a :						List[str]			       =  FalconForCausalLM.from_pretrained(_UpperCAmelCase     )
																	model.eval()
																	model.to(device=_UpperCAmelCase     )
																	__a :						str			       =  tokenizer('''My favorite food is'''	,			return_tensors='''pt'''     ).to(_UpperCAmelCase     )

																	# Test results are the same with and without cache
																	__a :						Optional[Any]			       =  model.generate(**_UpperCAmelCase	,			do_sample=_UpperCAmelCase	,			max_new_tokens=20	,			use_cache=_UpperCAmelCase     )
																	__a :						Dict			       =  model.generate(**_UpperCAmelCase	,			do_sample=_UpperCAmelCase	,			max_new_tokens=20	,			use_cache=_UpperCAmelCase     )
																	self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0     )






"""simple docstring"""






import copy
import re




class 				__lowercase			:







					'''simple docstring'''




					__lowerCAmelCase  =  '''hp'''
					__lowerCAmelCase  =  {}
					__lowerCAmelCase  =  None







					@classmethod
					def  _lowerCamelCase		(						cls	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Optional[int]			       =  prefix
									__a :						List[str]			       =  defaults
									cls.build_naming_info()







					@staticmethod
					def  _lowerCamelCase		(						_UpperCAmelCase	,			_UpperCAmelCase     ):
									if len(_UpperCAmelCase     ) == 0:
													return ""
									__a :						Optional[int]			       =  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(_UpperCAmelCase     ) + 1     ):
													__a :						str			       =  word[:prefix_len]
													if prefix in info["reverse_short_word"]:
																	continue
													else:
																	__a :						Tuple			       =  prefix
																	break

									if short_word is None:
													# Paranoid fallback
													def int_to_alphabetic(_UpperCAmelCase     ):
																	__a :						List[str]			       =  ''''''
																	while integer != 0:
																					__a :						Union[str, Any]			       =  chr(ord('''A'''     ) + integer % 10     ) + s
																					integer //= 10
																	return s

													__a :						Optional[int]			       =  0
													while True:
																	__a :						List[str]			       =  word + '''#''' + int_to_alphabetic(_UpperCAmelCase     )
																	if sword in info["reverse_short_word"]:
																					continue
																	else:
																					__a :						Optional[Any]			       =  sword
																					break

									__a :						List[str]			       =  short_word
									__a :						Dict			       =  word
									return short_word







					@staticmethod
					def  _lowerCamelCase		(						_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						str			       =  param_name.split('''_'''     )

									__a :						str			       =  [TrialShortNamer.shortname_for_word(_UpperCAmelCase	,			_UpperCAmelCase     ) 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 :						Dict			       =  ['''''', '''_''']

									for separator in separators:
													__a :						Union[str, Any]			       =  separator.join(_UpperCAmelCase     )
													if shortname not in info["reverse_short_param"]:
																	__a :						List[str]			       =  shortname
																	__a :						Union[str, Any]			       =  param_name
																	return shortname

									return param_name







					@staticmethod
					def  _lowerCamelCase		(						_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						int			       =  TrialShortNamer.shortname_for_key(_UpperCAmelCase	,			_UpperCAmelCase     )
									__a :						Optional[Any]			       =  short_name
									__a :						Optional[Any]			       =  param_name







					@classmethod
					def  _lowerCamelCase		(						cls     ):
									if cls.NAMING_INFO is not None:
													return

									__a :						Optional[Any]			       =  {
									    '''short_word''': {},
									    '''reverse_short_word''': {},
									    '''short_param''': {},
									    '''reverse_short_param''': {},
									}

									__a :						List[str]			       =  list(cls.DEFAULTS.keys()     )

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

									__a :						Optional[Any]			       =  info







					@classmethod
					def  _lowerCamelCase		(						cls	,			_UpperCAmelCase     ):
									cls.build_naming_info()
									assert cls.PREFIX is not None
									__a :						str			       =  [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 :						Union[str, Any]			       =  cls.NAMING_INFO['''short_param'''][k]

													if isinstance(_UpperCAmelCase	,			_UpperCAmelCase     ):
																	__a :						str			       =  1 if v else 0

													__a :						Tuple			       =  '''''' if isinstance(_UpperCAmelCase	,			(int, float)     ) else '''-'''
													__a :						Dict			       =  f"""{key}{sep}{v}"""
													name.append(_UpperCAmelCase     )

									return "_".join(_UpperCAmelCase     )







					@classmethod
					def  _lowerCamelCase		(						cls	,			_UpperCAmelCase     ):
									__a :						List[Any]			       =  repr[len(cls.PREFIX     ) + 1 :]
									if repr == "":
													__a :						Tuple			       =  []
									else:
													__a :						str			       =  repr.split('''_'''     )

									__a :						Optional[Any]			       =  {}

									for value in values:
													if "-" in value:
																	__a       ,						__a :						List[Any]			       =  value.split('''-'''     )
													else:
																	__a :						int			       =  re.sub('''[0-9.]'''	,			''''''	,			_UpperCAmelCase     )
																	__a :						Union[str, Any]			       =  float(re.sub('''[^0-9.]'''	,			''''''	,			_UpperCAmelCase     )     )

													__a :						Dict			       =  cls.NAMING_INFO['''reverse_short_param'''][p_k]

													__a :						Union[str, Any]			       =  p_v

									for k in cls.DEFAULTS:
													if k not in parameters:
																	__a :						Optional[int]			       =  cls.DEFAULTS[k]

									return parameters