





"""simple docstring"""






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
		import torch


A 			=  random.Random()

def     __A      (			a_						:Any   ,       a_						:str=1.0   ,       a_						:List[Any]=None   ,       a_						:Union[str, Any]=None)		->		List[Any]:
				if rng is None:
								__a :						List[Any]			       =  global_rng

				__a :						Union[str, Any]			       =  []
				for batch_idx in range(shape[0]):
								values.append([])
								for _ in range(shape[1]):
												values[-1].append(rng.random() * scale)

				return values




@require_torch
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase	,			_UpperCAmelCase=7	,			_UpperCAmelCase=400	,			_UpperCAmelCase=2000	,			_UpperCAmelCase=1	,			_UpperCAmelCase=0.0	,			_UpperCAmelCase=16000	,			_UpperCAmelCase=True	,			_UpperCAmelCase=80	,			_UpperCAmelCase=16	,			_UpperCAmelCase=64	,			_UpperCAmelCase="hann_window"	,			_UpperCAmelCase=80	,			_UpperCAmelCase=7600	,			_UpperCAmelCase=1e-1_0	,			_UpperCAmelCase=True	,			):
									__a :						Optional[Any]			       =  parent
									__a :						Union[str, Any]			       =  batch_size
									__a :						int			       =  min_seq_length
									__a :						Tuple			       =  max_seq_length
									__a :						List[Any]			       =  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									__a :						Any			       =  feature_size
									__a :						List[Any]			       =  padding_value
									__a :						Tuple			       =  sampling_rate
									__a :						int			       =  do_normalize
									__a :						str			       =  num_mel_bins
									__a :						List[str]			       =  hop_length
									__a :						Tuple			       =  win_length
									__a :						List[str]			       =  win_function
									__a :						List[str]			       =  fmin
									__a :						Dict			       =  fmax
									__a :						Tuple			       =  mel_floor
									__a :						Tuple			       =  return_attention_mask







					def  _lowerCamelCase		(						self     ):
									return {
									    "feature_size": self.feature_size,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "do_normalize": self.do_normalize,
									    "num_mel_bins": self.num_mel_bins,
									    "hop_length": self.hop_length,
									    "win_length": self.win_length,
									    "win_function": self.win_function,
									    "fmin": self.fmin,
									    "fmax": self.fmax,
									    "mel_floor": self.mel_floor,
									    "return_attention_mask": self.return_attention_mask,
									}







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase=False	,			_UpperCAmelCase=False     ):
									def _flatten(_UpperCAmelCase     ):
													return list(itertools.chain(*_a     )     )

									if equal_length:
													__a :						List[Any]			       =  floats_list((self.batch_size, self.max_seq_length)     )
									else:
													# make sure that inputs increase in size
													__a :						List[str]			       =  [
													    _flatten(floats_list((x, self.feature_size)     )     )
													    for x in range(self.min_seq_length	,			self.max_seq_length	,			self.seq_length_diff     )
													]

									if numpify:
													__a :						int			       =  [np.asarray(_a     ) for x in speech_inputs]

									return speech_inputs







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase=False	,			_UpperCAmelCase=False     ):
									if equal_length:
													__a :						int			       =  [floats_list((self.max_seq_length, self.num_mel_bins)     ) for _ in range(self.batch_size     )]
									else:
													# make sure that inputs increase in size
													__a :						str			       =  [
													    floats_list((x, self.num_mel_bins)     )
													    for x in range(self.min_seq_length	,			self.max_seq_length	,			self.seq_length_diff     )
													]

									if numpify:
													__a :						List[str]			       =  [np.asarray(_a     ) for x in speech_inputs]

									return speech_inputs






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







					'''simple docstring'''




					__lowerCAmelCase  =  SpeechTaFeatureExtractor







					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  SpeechTaFeatureExtractionTester(self     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase     ):
									self.assertTrue(np.all(np.mean(_a	,			axis=0     ) < 1e-3     )     )
									self.assertTrue(np.all(np.abs(np.var(_a	,			axis=0     ) - 1     ) < 1e-3     )     )







					def  _lowerCamelCase		(						self     ):
									# Tests that all call wrap to encode_plus and batch_encode_plus
									__a :						List[Any]			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									# create three inputs of length 800, 1000, and 1200
									__a :						int			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]
									__a :						int			       =  [np.asarray(_a     ) for speech_input in speech_inputs]

									# Test not batched input
									__a :						List[Any]			       =  feat_extract(speech_inputs[0]	,			return_tensors='''np'''     ).input_values
									__a :						Dict			       =  feat_extract(np_speech_inputs[0]	,			return_tensors='''np'''     ).input_values
									self.assertTrue(np.allclose(_a	,			_a	,			atol=1e-3     )     )

									# Test batched
									__a :						List[str]			       =  feat_extract(_a	,			return_tensors='''np'''     ).input_values
									__a :						List[str]			       =  feat_extract(_a	,			return_tensors='''np'''     ).input_values
									for enc_seq_a, enc_seq_a in zip(_a	,			_a     ):
													self.assertTrue(np.allclose(_a	,			_a	,			atol=1e-3     )     )







					def  _lowerCamelCase		(						self     ):
									__a :						str			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									__a :						Tuple			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]

									__a :						Any			       =  ["""longest""", """max_length""", """do_not_pad"""]
									__a :						Union[str, Any]			       =  [None, 1600, None]
									for max_length, padding in zip(_a	,			_a     ):
													__a :						Optional[Any]			       =  feat_extract(_a	,			padding=_a	,			max_length=_a	,			return_tensors='''np'''     )
													__a :						List[str]			       =  processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]     )
													self.assertTrue(input_values[0][800:].sum() < 1e-6     )
													self._check_zero_mean_unit_variance(input_values[1][:1000]     )
													self.assertTrue(input_values[0][1000:].sum() < 1e-6     )
													self._check_zero_mean_unit_variance(input_values[2][:1200]     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									__a :						List[str]			       =  range(800	,			1400	,			200     )
									__a :						Any			       =  [floats_list((1, x)     )[0] for x in lengths]

									__a :						List[Any]			       =  ["""longest""", """max_length""", """do_not_pad"""]
									__a :						Optional[Any]			       =  [None, 1600, None]

									for max_length, padding in zip(_a	,			_a     ):
													__a :						Optional[Any]			       =  feat_extract(_a	,			max_length=_a	,			padding=_a     )
													__a :						int			       =  processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]     )
													self._check_zero_mean_unit_variance(input_values[1][:1000]     )
													self._check_zero_mean_unit_variance(input_values[2][:1200]     )







					def  _lowerCamelCase		(						self     ):
									__a :						Tuple			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									__a :						str			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]
									__a :						Any			       =  feat_extract(
									    _a	,			truncation=_a	,			max_length=1000	,			padding='''max_length'''	,			return_tensors='''np'''     )
									__a :						Optional[Any]			       =  processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]     )
									self._check_zero_mean_unit_variance(input_values[1]     )
									self._check_zero_mean_unit_variance(input_values[2]     )







					def  _lowerCamelCase		(						self     ):
									__a :						Union[str, Any]			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									__a :						Dict			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]
									__a :						str			       =  feat_extract(
									    _a	,			truncation=_a	,			max_length=1000	,			padding='''longest'''	,			return_tensors='''np'''     )
									__a :						Any			       =  processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]     )
									self._check_zero_mean_unit_variance(input_values[1, :1000]     )
									self._check_zero_mean_unit_variance(input_values[2]     )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertTrue(input_values.shape == (3, 1000)     )

									__a :						List[Any]			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]
									__a :						Dict			       =  feat_extract(
									    _a	,			truncation=_a	,			max_length=2000	,			padding='''longest'''	,			return_tensors='''np'''     )
									__a :						List[str]			       =  processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]     )
									self._check_zero_mean_unit_variance(input_values[1, :1000]     )
									self._check_zero_mean_unit_variance(input_values[2]     )

									# make sure that if max_length > longest -> then pad to longest
									self.assertTrue(input_values.shape == (3, 1200)     )







					def  _lowerCamelCase		(						self     ):
									__a :						Dict			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									__a :						Any			       =  np.random.rand(100     ).astype(np.floataa     )
									__a :						str			       =  np_speech_inputs.tolist()

									for inputs in [py_speech_inputs, np_speech_inputs]:
													__a :						List[Any]			       =  feature_extractor.pad([{'''input_values''': inputs}]	,			return_tensors='''np'''     )
													self.assertTrue(np_processed.input_values.dtype == np.floataa     )
													__a :						Optional[Any]			       =  feature_extractor.pad([{'''input_values''': inputs}]	,			return_tensors='''pt'''     )
													self.assertTrue(pt_processed.input_values.dtype == torch.floataa     )







					def  _lowerCamelCase		(						self     ):
									# Tests that all call wrap to encode_plus and batch_encode_plus
									__a :						Any			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
									# create three inputs of length 800, 1000, and 1200
									__a :						Dict			       =  [floats_list((1, x)     )[0] for x in range(800	,			1400	,			200     )]
									__a :						Optional[Any]			       =  [np.asarray(_a     ) for speech_input in speech_inputs]

									# Test feature size
									__a :						Dict			       =  feature_extractor(audio_target=_a	,			padding=_a	,			return_tensors='''np'''     ).input_values
									self.assertTrue(input_values.ndim == 3     )
									self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins     )

									# Test not batched input
									__a :						Any			       =  feature_extractor(speech_inputs[0]	,			return_tensors='''np'''     ).input_values
									__a :						List[str]			       =  feature_extractor(np_speech_inputs[0]	,			return_tensors='''np'''     ).input_values
									self.assertTrue(np.allclose(_a	,			_a	,			atol=1e-3     )     )

									# Test batched
									__a :						Dict			       =  feature_extractor(_a	,			return_tensors='''np'''     ).input_values
									__a :						Optional[int]			       =  feature_extractor(_a	,			return_tensors='''np'''     ).input_values
									for enc_seq_a, enc_seq_a in zip(_a	,			_a     ):
													self.assertTrue(np.allclose(_a	,			_a	,			atol=1e-3     )     )

									# Test 2-D numpy arrays are batched.
									__a :						Tuple			       =  [floats_list((1, x)     )[0] for x in (800, 800, 800)]
									__a :						Tuple			       =  np.asarray(_a     )
									__a :						Union[str, Any]			       =  feature_extractor(_a	,			return_tensors='''np'''     ).input_values
									__a :						Optional[int]			       =  feature_extractor(_a	,			return_tensors='''np'''     ).input_values
									for enc_seq_a, enc_seq_a in zip(_a	,			_a     ):
													self.assertTrue(np.allclose(_a	,			_a	,			atol=1e-3     )     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  self.feat_extract_tester.prepare_inputs_for_target()
									__a :						Optional[Any]			       =  self.feature_extraction_class(**self.feat_extract_dict     )
									__a :						List[Any]			       =  feat_extract.model_input_names[0]

									__a :						Union[str, Any]			       =  BatchFeature({input_name: speech_inputs}     )

									self.assertTrue(all(len(_a     ) == len(_a     ) for x, y in zip(_a	,			processed_features[input_name]     )     )     )

									__a :						Any			       =  self.feat_extract_tester.prepare_inputs_for_target(equal_length=_a     )
									__a :						Any			       =  BatchFeature({input_name: speech_inputs}	,			tensor_type='''np'''     )

									__a :						Tuple			       =  processed_features[input_name]

									if len(batch_features_input.shape     ) < 3:
													__a :						str			       =  batch_features_input[:, :, None]

									self.assertTrue(
									    batch_features_input.shape
									    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]     ), self.feat_extract_tester.num_mel_bins)     )







					@require_torch
					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  self.feat_extract_tester.prepare_inputs_for_target(equal_length=_a     )
									__a :						Union[str, Any]			       =  self.feature_extraction_class(**self.feat_extract_dict     )
									__a :						Any			       =  feat_extract.model_input_names[0]

									__a :						Union[str, Any]			       =  BatchFeature({input_name: speech_inputs}	,			tensor_type='''pt'''     )

									__a :						int			       =  processed_features[input_name]

									if len(batch_features_input.shape     ) < 3:
													__a :						int			       =  batch_features_input[:, :, None]

									self.assertTrue(
									    batch_features_input.shape
									    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]     ), self.feat_extract_tester.num_mel_bins)     )







					@require_torch
					def  _lowerCamelCase		(						self     ):
									__a :						Optional[Any]			       =  self.feature_extraction_class(**self.feat_extract_dict     )
									__a :						Any			       =  self.feat_extract_tester.prepare_inputs_for_target()
									__a :						Any			       =  feat_extract.model_input_names[0]

									__a :						Optional[Any]			       =  BatchFeature({input_name: speech_inputs}     )

									__a :						Dict			       =  feat_extract.num_mel_bins  # hack!

									__a :						Union[str, Any]			       =  feat_extract.pad(_a	,			padding='''longest'''	,			return_tensors='''np'''     )[input_name]
									__a :						Union[str, Any]			       =  feat_extract.pad(_a	,			padding='''longest'''	,			return_tensors='''pt'''     )[input_name]

									self.assertTrue(abs(input_np.astype(np.floataa     ).sum() - input_pt.numpy().astype(np.floataa     ).sum()     ) < 1e-2     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  self.feat_extract_dict
									__a :						Any			       =  True
									__a :						List[Any]			       =  self.feature_extraction_class(**_a     )
									__a :						List[Any]			       =  self.feat_extract_tester.prepare_inputs_for_target()
									__a :						str			       =  [len(_a     ) for x in speech_inputs]
									__a :						Dict			       =  feat_extract.model_input_names[0]

									__a :						str			       =  BatchFeature({input_name: speech_inputs}     )

									__a :						Tuple			       =  feat_extract.num_mel_bins  # hack!

									__a :						Tuple			       =  feat_extract.pad(_a	,			padding='''longest'''	,			return_tensors='''np'''     )
									self.assertIn('''attention_mask'''	,			_a     )
									self.assertListEqual(list(processed.attention_mask.shape     )	,			list(processed[input_name].shape[:2]     )     )
									self.assertListEqual(processed.attention_mask.sum(-1     ).tolist()	,			_a     )







					def  _lowerCamelCase		(						self     ):
									__a :						Union[str, Any]			       =  self.feat_extract_dict
									__a :						int			       =  True
									__a :						Optional[Any]			       =  self.feature_extraction_class(**_a     )
									__a :						Any			       =  self.feat_extract_tester.prepare_inputs_for_target()
									__a :						Dict			       =  [len(_a     ) for x in speech_inputs]
									__a :						Tuple			       =  feat_extract.model_input_names[0]

									__a :						Optional[Any]			       =  BatchFeature({input_name: speech_inputs}     )
									__a :						str			       =  min(_a     )

									__a :						Any			       =  feat_extract.num_mel_bins  # hack!

									__a :						Union[str, Any]			       =  feat_extract.pad(
									    _a	,			padding='''max_length'''	,			max_length=_a	,			truncation=_a	,			return_tensors='''np'''     )
									self.assertIn('''attention_mask'''	,			_a     )
									self.assertListEqual(
									    list(processed_pad.attention_mask.shape     )	,			[processed_pad[input_name].shape[0], max_length]     )
									self.assertListEqual(
									    processed_pad.attention_mask[:, :max_length].sum(-1     ).tolist()	,			[max_length for x in speech_inputs]     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase     ):
									from datasets import load_dataset

									__a :						Optional[Any]			       =  load_dataset('''hf-internal-testing/librispeech_asr_dummy'''	,			'''clean'''	,			split='''validation'''     )
									# automatic decoding with librispeech
									__a :						Optional[Any]			       =  ds.sort('''id'''     ).select(range(_a     )     )[:num_samples]["""audio"""]

									return [x["array"] for x in speech_samples]







					def  _lowerCamelCase		(						self     ):
									# fmt: off
									__a :						int			       =  torch.tensor(
									    [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
									     3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
									     2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
									     4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
									     7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
									     4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]     )
									# fmt: on

									__a :						List[str]			       =  self._load_datasamples(1     )
									__a :						Optional[Any]			       =  SpeechTaFeatureExtractor()
									__a :						Dict			       =  feature_extractor(_a	,			return_tensors='''pt'''     ).input_values
									self.assertEquals(input_values.shape	,			(1, 93680)     )
									self.assertTrue(torch.allclose(input_values[0, :30]	,			_a	,			atol=1e-6     )     )







					def  _lowerCamelCase		(						self     ):
									# fmt: off
									__a :						Tuple			       =  torch.tensor(
									    [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
									     -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
									     -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
									     -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8]     )
									# fmt: on

									__a :						Dict			       =  self._load_datasamples(1     )
									__a :						Any			       =  SpeechTaFeatureExtractor()
									__a :						List[str]			       =  feature_extractor(audio_target=_a	,			return_tensors='''pt'''     ).input_values
									self.assertEquals(input_values.shape	,			(1, 366, 80)     )
									self.assertTrue(torch.allclose(input_values[0, 0, :30]	,			_a	,			atol=1e-4     )     )










"""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