from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TFConvBertForMaskedLM,
	    TFConvBertForMultipleChoice,
	    TFConvBertForQuestionAnswering,
	    TFConvBertForSequenceClassification,
	    TFConvBertForTokenClassification,
	    TFConvBertModel,
	)


class 						a__      :



			def __init__(						self				,						UpperCAmelCase				,						UpperCAmelCase=1_3				,						UpperCAmelCase=7				,						UpperCAmelCase=True				,						UpperCAmelCase=True				,						UpperCAmelCase=True				,						UpperCAmelCase=True				,						UpperCAmelCase=9_9				,						UpperCAmelCase=3_2				,						UpperCAmelCase=2				,						UpperCAmelCase=4				,						UpperCAmelCase=3_7				,						UpperCAmelCase="gelu"				,						UpperCAmelCase=0.1				,						UpperCAmelCase=0.1				,						UpperCAmelCase=5_1_2				,						UpperCAmelCase=1_6				,						UpperCAmelCase=2				,						UpperCAmelCase=0.02				,						UpperCAmelCase=3				,						UpperCAmelCase=4				,						UpperCAmelCase=None				,						)			->   Optional[int]:
								__a		 =       parent
								__a		 =       1_3
								__a		 =       7
								__a		 =       True
								__a		 =       True
								__a		 =       True
								__a		 =       True
								__a		 =       9_9
								__a		 =       3_8_4
								__a		 =       2
								__a		 =       4
								__a		 =       3_7
								__a		 =       'gelu'
								__a		 =       0.1
								__a		 =       0.1
								__a		 =       5_1_2
								__a		 =       1_6
								__a		 =       2
								__a		 =       0.02
								__a		 =       3
								__a		 =       4
								__a		 =       1_2_8
								__a		 =       2
								__a		 =       9
								__a		 =       1
								__a		 =       None



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       ids_tensor([self.batch_size, self.seq_length]				,						self.vocab_size   )

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

								__a		 =       None
								if self.use_token_type_ids:
													__a		 =       ids_tensor([self.batch_size, self.seq_length]				,						self.type_vocab_size   )

								__a		 =       None
								__a		 =       None
								__a		 =       None
								if self.use_labels:
													__a		 =       ids_tensor([self.batch_size]				,						self.type_sequence_label_size   )
													__a		 =       ids_tensor([self.batch_size, self.seq_length]				,						self.num_labels   )
													__a		 =       ids_tensor([self.batch_size]				,						self.num_choices   )

								__a		 =       ConvBertConfig(
								    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				,						initializer_range=self.initializer_range				,						return_dict=UpperCAmelCase				,						)

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



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Optional[int]:
								__a		 =       TFConvBertModel(config=UpperCAmelCase   )
								__a		 =       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

								__a		 =       [input_ids, input_mask]
								__a		 =       model(UpperCAmelCase   )

								__a		 =       model(UpperCAmelCase   )

								self.parent.assertEqual(result.last_hidden_state.shape				,						(self.batch_size, self.seq_length, self.hidden_size)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Any:
								__a		 =       TFConvBertForMaskedLM(config=UpperCAmelCase   )
								__a		 =       {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}
								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.seq_length, self.vocab_size)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Optional[int]:
								__a		 =       self.num_labels
								__a		 =       TFConvBertForSequenceClassification(config=UpperCAmelCase   )
								__a		 =       {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}

								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.num_labels)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Tuple:
								__a		 =       self.num_choices
								__a		 =       TFConvBertForMultipleChoice(config=UpperCAmelCase   )
								__a		 =       tf.tile(tf.expand_dims(UpperCAmelCase				,						1   )				,						(1, self.num_choices, 1)   )
								__a		 =       tf.tile(tf.expand_dims(UpperCAmelCase				,						1   )				,						(1, self.num_choices, 1)   )
								__a		 =       tf.tile(tf.expand_dims(UpperCAmelCase				,						1   )				,						(1, self.num_choices, 1)   )
								__a		 =       {
								    'input_ids': multiple_choice_inputs_ids,
								    'attention_mask': multiple_choice_input_mask,
								    'token_type_ids': multiple_choice_token_type_ids,
								}
								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.num_choices)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   str:
								__a		 =       self.num_labels
								__a		 =       TFConvBertForTokenClassification(config=UpperCAmelCase   )
								__a		 =       {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}
								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.seq_length, self.num_labels)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Optional[int]:
								__a		 =       TFConvBertForQuestionAnswering(config=UpperCAmelCase   )
								__a		 =       {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'token_type_ids': token_type_ids,
								}

								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.start_logits.shape				,						(self.batch_size, self.seq_length)   )
								self.parent.assertEqual(result.end_logits.shape				,						(self.batch_size, self.seq_length)   )







			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       self.prepare_config_and_inputs()
								(
								    (
								    __a				
								) ,				(
								    __a				
								) ,				(
								    __a				
								) ,				(
								    __a				
								) ,				(
								    __a				
								) ,				(
								    __a				
								) ,				(
								    __a				
								) ,								
								)		 =       config_and_inputs
								__a		 =       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict






@require_tf
class 						a__      (       __snake_case				,						__snake_case				,						unittest.TestCase		):
			A__    :       List[str]        =      (
			    (
			        TFConvBertModel,
			        TFConvBertForMaskedLM,
			        TFConvBertForQuestionAnswering,
			        TFConvBertForSequenceClassification,
			        TFConvBertForTokenClassification,
			        TFConvBertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			A__    :       Dict        =      (
			    {
			        'feature-extraction': TFConvBertModel,
			        'fill-mask': TFConvBertForMaskedLM,
			        'question-answering': TFConvBertForQuestionAnswering,
			        'text-classification': TFConvBertForSequenceClassification,
			        'token-classification': TFConvBertForTokenClassification,
			        'zero-shot': TFConvBertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			A__    :       Optional[int]        =      False
			A__    :       Dict        =      False
			A__    :       Union[str, Any]        =      False



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Dict:
								__a		 =       TFConvBertModelTester(self   )
								__a		 =       ConfigTester(self				,						config_class=UpperCAmelCase				,						hidden_size=3_7   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[Any]:
								self.config_tester.run_common_tests()



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Any:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase   )



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a ,				__a		 =       self.model_tester.prepare_config_and_inputs_for_common()
								__a		 =       True
								__a		 =       True

								if hasattr(UpperCAmelCase				,						'use_cache'   ):
													__a		 =       True

								__a		 =       getattr(self.model_tester				,						'encoder_seq_length'				,						self.model_tester.seq_length   )
								__a		 =       getattr(self.model_tester				,						'key_length'				,						UpperCAmelCase   )

								for model_class in self.all_model_classes:
													__a		 =       self._prepare_for_class(UpperCAmelCase				,						UpperCAmelCase   )
													__a		 =       model_class(UpperCAmelCase   )
													__a		 =       len(model(UpperCAmelCase   )   )

													with tempfile.TemporaryDirectory() as tmpdirname:
																		model.save_pretrained(UpperCAmelCase				,						saved_model=UpperCAmelCase   )
																		__a		 =       os.path.join(UpperCAmelCase				,						'saved_model'				,						'1'   )
																		__a		 =       tf.keras.models.load_model(UpperCAmelCase   )
																		__a		 =       model(UpperCAmelCase   )

																		if self.is_encoder_decoder:
																							__a		 =       outputs['encoder_hidden_states']
																							__a		 =       outputs['encoder_attentions']
																		else:
																							__a		 =       outputs['hidden_states']
																							__a		 =       outputs['attentions']

																		self.assertEqual(len(UpperCAmelCase   )				,						UpperCAmelCase   )

																		__a		 =       getattr(
																		    self.model_tester				,						'expected_num_hidden_layers'				,						self.model_tester.num_hidden_layers + 1   )

																		self.assertEqual(len(UpperCAmelCase   )				,						UpperCAmelCase   )
																		self.assertListEqual(
																		    list(output_hidden_states[0].shape[-2:]   )				,						[self.model_tester.seq_length, self.model_tester.hidden_size]				,						)

																		self.assertEqual(len(UpperCAmelCase   )				,						self.model_tester.num_hidden_layers   )
																		self.assertListEqual(
																		    list(output_attentions[0].shape[-3:]   )				,						[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]				,						)



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a		 =       TFConvBertModel.from_pretrained('YituTech/conv-bert-base'   )
								self.assertIsNotNone(UpperCAmelCase   )







			def __SCREAMING_SNAKE_CASE							(						self   )			->   Any:
								__a ,				__a		 =       self.model_tester.prepare_config_and_inputs_for_common()
								__a		 =       True
								__a		 =       getattr(self.model_tester				,						'decoder_seq_length'				,						self.model_tester.seq_length   )
								__a		 =       getattr(self.model_tester				,						'encoder_seq_length'				,						self.model_tester.seq_length   )
								__a		 =       getattr(self.model_tester				,						'key_length'				,						UpperCAmelCase   )
								__a		 =       getattr(self.model_tester				,						'key_length'				,						UpperCAmelCase   )

								def check_decoder_attentions_output(UpperCAmelCase   ):
													__a		 =       len(UpperCAmelCase   )
													self.assertEqual(out_len % 2				,						0   )
													__a		 =       outputs.decoder_attentions
													self.assertEqual(len(UpperCAmelCase   )				,						self.model_tester.num_hidden_layers   )
													self.assertListEqual(
													    list(decoder_attentions[0].shape[-3:]   )				,						[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]				,						)

								def check_encoder_attentions_output(UpperCAmelCase   ):
													__a		 =       [
													    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
													]
													self.assertEqual(len(UpperCAmelCase   )				,						self.model_tester.num_hidden_layers   )
													self.assertListEqual(
													    list(attentions[0].shape[-3:]   )				,						[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]				,						)

								for model_class in self.all_model_classes:
													__a		 =       True
													__a		 =       False
													__a		 =       model_class(UpperCAmelCase   )
													__a		 =       model(self._prepare_for_class(UpperCAmelCase				,						UpperCAmelCase   )   )
													__a		 =       len(UpperCAmelCase   )
													self.assertEqual(config.output_hidden_states				,						UpperCAmelCase   )
													check_encoder_attentions_output(UpperCAmelCase   )

													if self.is_encoder_decoder:
																		__a		 =       model_class(UpperCAmelCase   )
																		__a		 =       model(self._prepare_for_class(UpperCAmelCase				,						UpperCAmelCase   )   )
																		self.assertEqual(config.output_hidden_states				,						UpperCAmelCase   )
																		check_decoder_attentions_output(UpperCAmelCase   )

													# Check that output attentions can also be changed via the config
													del inputs_dict["output_attentions"]
													__a		 =       True
													__a		 =       model_class(UpperCAmelCase   )
													__a		 =       model(self._prepare_for_class(UpperCAmelCase				,						UpperCAmelCase   )   )
													self.assertEqual(config.output_hidden_states				,						UpperCAmelCase   )
													check_encoder_attentions_output(UpperCAmelCase   )

													# Check attention is always last and order is fine
													__a		 =       True
													__a		 =       True
													__a		 =       model_class(UpperCAmelCase   )
													__a		 =       model(self._prepare_for_class(UpperCAmelCase				,						UpperCAmelCase   )   )

													self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)				,						len(UpperCAmelCase   )   )
													self.assertEqual(model.config.output_hidden_states				,						UpperCAmelCase   )
													check_encoder_attentions_output(UpperCAmelCase   )






@require_tf
class 						a__      (       unittest.TestCase		):



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       TFConvBertModel.from_pretrained('YituTech/conv-bert-base'   )
								__a		 =       tf.constant([[0, 1, 2, 3, 4, 5]]   )
								__a		 =       model(UpperCAmelCase   )[0]

								__a		 =       [1, 6, 7_6_8]
								self.assertEqual(output.shape				,						UpperCAmelCase   )

								__a		 =       tf.constant(
								    [
								        [
								            [-0.03_475_493, -0.4_686_034, -0.30_638_832],
								            [0.22_637_248, -0.26_988_646, -0.7_423_424],
								            [0.10_324_868, -0.45_013_508, -0.58_280_784],
								        ]
								    ]   )
								tf.debugging.assert_near(output[:, :3, :3]				,						UpperCAmelCase				,						atol=1e-4   )





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs


class 						a__							(       __snake_case		):



			def __init__(						self				,						UpperCAmelCase				,						UpperCAmelCase=None				,						UpperCAmelCase=True				,						UpperCAmelCase=None				,						**UpperCAmelCase   )			->   List[Any]:
								__a		 =       parent
								__a		 =       config_class
								__a		 =       has_text_modality
								__a		 =       kwargs
								__a		 =       common_properties



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       self.config_class(**self.inputs_dict   )
								__a		 =       (
								    ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
								    if self.common_properties is None
								    else self.common_properties
								)

								# Add common fields for text models
								if self.has_text_modality:
													common_properties.extend(['vocab_size']   )

								# Test that config has the common properties as getters
								for prop in common_properties:
													self.parent.assertTrue(hasattr(UpperCAmelCase				,						UpperCAmelCase   )				,						msg=f'''`{prop}` does not exist'''   )

								# Test that config has the common properties as setter
								for idx, name in enumerate(UpperCAmelCase   ):
													try:
																		setattr(UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )
																		self.parent.assertEqual(
																		    getattr(UpperCAmelCase				,						UpperCAmelCase   )				,						UpperCAmelCase				,						msg=f'''`{name} value {idx} expected, but was {getattr(UpperCAmelCase				,						UpperCAmelCase   )}'''   )
													except NotImplementedError:
																		# Some models might not be able to implement setters for common_properties
																		# In that case, a NotImplementedError is raised
																		pass

        # Test if config class can be called with Config(prop_name=..)
								for idx, name in enumerate(UpperCAmelCase   ):
													try:
																		__a		 =       self.config_class(**{name: idx}   )
																		self.parent.assertEqual(
																		    getattr(UpperCAmelCase				,						UpperCAmelCase   )				,						UpperCAmelCase				,						msg=f'''`{name} value {idx} expected, but was {getattr(UpperCAmelCase				,						UpperCAmelCase   )}'''   )
													except NotImplementedError:
																		# Some models might not be able to implement setters for common_properties
																		# In that case, a NotImplementedError is raised
																		pass



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a		 =       self.config_class(**self.inputs_dict   )
								__a		 =       json.loads(config.to_json_string()   )
								for key, value in self.inputs_dict.items():
													self.parent.assertEqual(obj[key]				,						UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a		 =       self.config_class(**self.inputs_dict   )

								with tempfile.TemporaryDirectory() as tmpdirname:
													__a		 =       os.path.join(UpperCAmelCase				,						'config.json'   )
													config_first.to_json_file(UpperCAmelCase   )
													__a		 =       self.config_class.from_json_file(UpperCAmelCase   )

								self.parent.assertEqual(config_second.to_dict()				,						config_first.to_dict()   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a		 =       self.config_class(**self.inputs_dict   )

								with tempfile.TemporaryDirectory() as tmpdirname:
													config_first.save_pretrained(UpperCAmelCase   )
													__a		 =       self.config_class.from_pretrained(UpperCAmelCase   )

								self.parent.assertEqual(config_second.to_dict()				,						config_first.to_dict()   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								__a		 =       self.config_class(**self.inputs_dict   )

								__a		 =       'test'
								with tempfile.TemporaryDirectory() as tmpdirname:
													__a		 =       os.path.join(UpperCAmelCase				,						UpperCAmelCase   )
													config_first.save_pretrained(UpperCAmelCase   )
													__a		 =       self.config_class.from_pretrained(UpperCAmelCase				,						subfolder=UpperCAmelCase   )

								self.parent.assertEqual(config_second.to_dict()				,						config_first.to_dict()   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       self.config_class(**self.inputs_dict				,						num_labels=5   )
								self.parent.assertEqual(len(config.idalabel   )				,						5   )
								self.parent.assertEqual(len(config.labelaid   )				,						5   )

								__a		 =       3
								self.parent.assertEqual(len(config.idalabel   )				,						3   )
								self.parent.assertEqual(len(config.labelaid   )				,						3   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								if self.config_class.is_composition:
													return
								__a		 =       self.config_class()
								self.parent.assertIsNotNone(UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       copy.deepcopy(UpperCAmelCase   )
								__a		 =       self.config_class(**UpperCAmelCase   )
								__a		 =       []
								for key, value in config_common_kwargs.items():
													if key == "torch_dtype":
																		if not is_torch_available():
																							continue
																		else:
																							import torch

																							if config.torch_dtype != torch.floataa:
																												wrong_values.append(('torch_dtype', config.torch_dtype, torch.floataa)   )
													elif getattr(UpperCAmelCase				,						UpperCAmelCase   ) != value:
																		wrong_values.append((key, getattr(UpperCAmelCase				,						UpperCAmelCase   ), value)   )

								if len(UpperCAmelCase   ) > 0:
													__a		 =       '\n'.join([f'''- {v[0]}: got {v[1]} instead of {v[2]}''' for v in wrong_values]   )
													raise ValueError(f'''The following keys were not properly set in the config:\n{errors}'''   )







			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								self.create_and_test_config_common_properties()
								self.create_and_test_config_to_json_string()
								self.create_and_test_config_to_json_file()
								self.create_and_test_config_from_and_save_pretrained()
								self.create_and_test_config_from_and_save_pretrained_subfolder()
								self.create_and_test_config_with_num_labels()
								self.check_config_can_be_init_without_params()
								self.check_config_arguments_init()




