



"""simple docstring"""

import copy
import os
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union


if TYPE_CHECKING:
							from ...processing_utils import ProcessorMixin
							from ...utils import TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A_						:    Union[str, Any]				=      logging.get_logger(__name__)

A_						:    str				=      {
    'google/owlvit-base-patch32': 'https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json',
    'google/owlvit-base-patch16': 'https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json',
    'google/owlvit-large-patch14': 'https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json',
}
class     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		Any  						= '''owlvit_text_model'''





	def __init__(      self				:       str     ,       _SCREAMING_SNAKE_CASE				:       Dict=49_408     ,       _SCREAMING_SNAKE_CASE				:       Any=512     ,       _SCREAMING_SNAKE_CASE				:       Dict=2_048     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]=12     ,       _SCREAMING_SNAKE_CASE				:       int=8     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]=16     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]="quick_gelu"     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=1E-5     ,       _SCREAMING_SNAKE_CASE				:       Any=0.0     ,       _SCREAMING_SNAKE_CASE				:       Tuple=0.0_2     ,       _SCREAMING_SNAKE_CASE				:       Dict=1.0     ,       _SCREAMING_SNAKE_CASE				:       Any=0     ,       _SCREAMING_SNAKE_CASE				:       Tuple=49_406     ,       _SCREAMING_SNAKE_CASE				:       Tuple=49_407     ,       **_SCREAMING_SNAKE_CASE				:       Optional[int]     ,       )						->	Optional[Any]:





					"""simple docstring"""


					super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE     ,       bos_token_id=_SCREAMING_SNAKE_CASE     ,       eos_token_id=_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE						:							int							=     vocab_size
					SCREAMING_SNAKE_CASE						:							str							=     hidden_size
					SCREAMING_SNAKE_CASE						:							str							=     intermediate_size
					SCREAMING_SNAKE_CASE						:							Dict							=     num_hidden_layers
					SCREAMING_SNAKE_CASE						:							Tuple							=     num_attention_heads
					SCREAMING_SNAKE_CASE						:							Any							=     max_position_embeddings
					SCREAMING_SNAKE_CASE						:							str							=     hidden_act
					SCREAMING_SNAKE_CASE						:							List[Any]							=     layer_norm_eps
					SCREAMING_SNAKE_CASE						:							str							=     attention_dropout
					SCREAMING_SNAKE_CASE						:							str							=     initializer_range
					SCREAMING_SNAKE_CASE						:							int							=     initializer_factor







	@classmethod
	def 			_lowerCAmelCase     (      cls				:       Dict     ,       _SCREAMING_SNAKE_CASE				:       Union[str, os.PathLike]     ,       **_SCREAMING_SNAKE_CASE				:       Optional[int]    )						->	"PretrainedConfig":





					"""simple docstring"""


					cls._set_token_in_kwargs(_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						:							Optional[int]							=     cls.get_config_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )

					# get the text config dict if we are loading from OwlViTConfig
					if config_dict.get('model_type'    ) == "owlvit":
									SCREAMING_SNAKE_CASE						:							Optional[Any]							=     config_dict['text_config']

					if "model_type" in config_dict and hasattr(cls     ,       'model_type'    ) and config_dict["model_type"] != cls.model_type:
									logger.warning(
									    f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
									    f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""    )

					return cls.from_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )




class     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		Union[str, Any]  						= '''owlvit_vision_model'''





	def __init__(      self				:       Optional[int]     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=768     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=3_072     ,       _SCREAMING_SNAKE_CASE				:       int=12     ,       _SCREAMING_SNAKE_CASE				:       Dict=12     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]=3     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=768     ,       _SCREAMING_SNAKE_CASE				:       Tuple=32     ,       _SCREAMING_SNAKE_CASE				:       List[str]="quick_gelu"     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=1E-5     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]=0.0     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=0.0_2     ,       _SCREAMING_SNAKE_CASE				:       int=1.0     ,       **_SCREAMING_SNAKE_CASE				:       Tuple     ,       )						->	List[str]:





					"""simple docstring"""


					super().__init__(**_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE						:							str							=     hidden_size
					SCREAMING_SNAKE_CASE						:							List[Any]							=     intermediate_size
					SCREAMING_SNAKE_CASE						:							str							=     num_hidden_layers
					SCREAMING_SNAKE_CASE						:							Tuple							=     num_attention_heads
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     num_channels
					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     image_size
					SCREAMING_SNAKE_CASE						:							Any							=     patch_size
					SCREAMING_SNAKE_CASE						:							str							=     hidden_act
					SCREAMING_SNAKE_CASE						:							Any							=     layer_norm_eps
					SCREAMING_SNAKE_CASE						:							Dict							=     attention_dropout
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     initializer_range
					SCREAMING_SNAKE_CASE						:							int							=     initializer_factor







	@classmethod
	def 			_lowerCAmelCase     (      cls				:       int     ,       _SCREAMING_SNAKE_CASE				:       Union[str, os.PathLike]     ,       **_SCREAMING_SNAKE_CASE				:       Optional[int]    )						->	"PretrainedConfig":





					"""simple docstring"""


					cls._set_token_in_kwargs(_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						:							List[str]							=     cls.get_config_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )

					# get the vision config dict if we are loading from OwlViTConfig
					if config_dict.get('model_type'    ) == "owlvit":
									SCREAMING_SNAKE_CASE						:							str							=     config_dict['vision_config']

					if "model_type" in config_dict and hasattr(cls     ,       'model_type'    ) and config_dict["model_type"] != cls.model_type:
									logger.warning(
									    f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
									    f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""    )

					return cls.from_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )




class     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		str  						= '''owlvit'''
	_SCREAMING_SNAKE_CASE	:		Dict  						= True





	def __init__(      self				:       str     ,       _SCREAMING_SNAKE_CASE				:       List[Any]=None     ,       _SCREAMING_SNAKE_CASE				:       str=None     ,       _SCREAMING_SNAKE_CASE				:       List[str]=512     ,       _SCREAMING_SNAKE_CASE				:       str=2.6_5_9_2     ,       _SCREAMING_SNAKE_CASE				:       int=True     ,       **_SCREAMING_SNAKE_CASE				:       Union[str, Any]     ,       )						->	Dict:





					"""simple docstring"""


					super().__init__(**_SCREAMING_SNAKE_CASE    )

					if text_config is None:
									SCREAMING_SNAKE_CASE						:							str							=     {}
									logger.info('text_config is None. Initializing the OwlViTTextConfig with default values.'    )

					if vision_config is None:
									SCREAMING_SNAKE_CASE						:							Tuple							=     {}
									logger.info('vision_config is None. initializing the OwlViTVisionConfig with default values.'    )

					SCREAMING_SNAKE_CASE						:							List[Any]							=     OwlViTTextConfig(**_SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							Dict							=     OwlViTVisionConfig(**_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE						:							str							=     projection_dim
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     logit_scale_init_value
					SCREAMING_SNAKE_CASE						:							Dict							=     return_dict
					SCREAMING_SNAKE_CASE						:							str							=     1.0





	@classmethod
	def 			_lowerCAmelCase     (      cls				:       Union[str, Any]     ,       _SCREAMING_SNAKE_CASE				:       Union[str, os.PathLike]     ,       **_SCREAMING_SNAKE_CASE				:       List[Any]    )						->	"PretrainedConfig":





					"""simple docstring"""


					cls._set_token_in_kwargs(_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						:							List[Any]							=     cls.get_config_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )

					if "model_type" in config_dict and hasattr(cls     ,       'model_type'    ) and config_dict["model_type"] != cls.model_type:
									logger.warning(
									    f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
									    f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""    )

					return cls.from_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )





	@classmethod
	def 			_lowerCAmelCase     (      cls				:       int     ,       _SCREAMING_SNAKE_CASE				:       Dict     ,       _SCREAMING_SNAKE_CASE				:       Dict     ,       **_SCREAMING_SNAKE_CASE				:       List[Any]    )						->	str:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[Any]							=     {}
					SCREAMING_SNAKE_CASE						:							str							=     text_config
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     vision_config

					return cls.from_dict(_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )







	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	List[Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[Any]							=     copy.deepcopy(self.__dict__    )
					SCREAMING_SNAKE_CASE						:							Dict							=     self.text_config.to_dict()
					SCREAMING_SNAKE_CASE						:							str							=     self.vision_config.to_dict()
					SCREAMING_SNAKE_CASE						:							Dict							=     self.__class__.model_type
					return output




class     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	@property
	def 			_lowerCAmelCase     (      self				:       int    )						->	Mapping[str, Mapping[int, str]]:





					"""simple docstring"""


					return OrderedDict(
					    [
					        ('input_ids', {0: 'batch', 1: 'sequence'}),
					        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
					        ('attention_mask', {0: 'batch', 1: 'sequence'}),
					    ]    )





	@property
	def 			_lowerCAmelCase     (      self				:       str    )						->	Mapping[str, Mapping[int, str]]:





					"""simple docstring"""


					return OrderedDict(
					    [
					        ('logits_per_image', {0: 'batch'}),
					        ('logits_per_text', {0: 'batch'}),
					        ('text_embeds', {0: 'batch'}),
					        ('image_embeds', {0: 'batch'}),
					    ]    )





	@property
	def 			_lowerCAmelCase     (      self				:       Union[str, Any]    )						->	float:





					"""simple docstring"""


					return 1E-4





	def 			_lowerCAmelCase     (      self				:       List[str]     ,       _SCREAMING_SNAKE_CASE				:       "ProcessorMixin"     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       int = -1     ,       _SCREAMING_SNAKE_CASE				:       Optional["TensorType"] = None     ,       )						->	Mapping[str, Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Optional[int]							=     super().generate_dummy_inputs(
					    processor.tokenizer     ,       batch_size=_SCREAMING_SNAKE_CASE     ,       seq_length=_SCREAMING_SNAKE_CASE     ,       framework=_SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							str							=     super().generate_dummy_inputs(
					    processor.image_processor     ,       batch_size=_SCREAMING_SNAKE_CASE     ,       framework=_SCREAMING_SNAKE_CASE    )
					return {**text_input_dict, **image_input_dict}







	@property
	def 			_lowerCAmelCase     (      self				:       Optional[Any]    )						->	int:





					"""simple docstring"""


					return 14










"""simple docstring"""

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


A_						:    int				=      get_tests_dir('fixtures')
A_						:    int				=      get_tests_dir('fixtures/dummy_feature_extractor_config.json')
A_						:    Dict				=      get_tests_dir('fixtures/dummy-config.json')
class     lowerCAmelCase__						(	unittest.TestCase ):


	'''simple docstring'''







	def 			_lowerCAmelCase     (      self				:       int    )						->	Tuple:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     0





	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	Tuple:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Any							=     AutoFeatureExtractor.from_pretrained('facebook/wav2vec2-base-960h'    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Dict:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       Optional[Any]    )						->	Optional[int]:





					"""simple docstring"""


					with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE						:							List[Any]							=     WavaVecaConfig()

									# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
									SCREAMING_SNAKE_CASE						:							Optional[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    ).to_dict()

									config_dict.pop('feature_extractor_type'    )
									SCREAMING_SNAKE_CASE						:							int							=     WavaVecaFeatureExtractor(**_SCREAMING_SNAKE_CASE    )

									# save in new folder
									model_config.save_pretrained(_SCREAMING_SNAKE_CASE    )
									config.save_pretrained(_SCREAMING_SNAKE_CASE    )

									SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )

									# make sure private variable is not incorrectly saved
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     json.loads(config.to_json_string()    )
									self.assertTrue('_processor_class' not in dict_as_saved    )

					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	int:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Union[str, Any]:





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       'bert-base is not a local folder and is not a valid model identifier'    ):
									SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained('bert-base'    )





	def 			_lowerCAmelCase     (      self				:       str    )						->	str:





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'    ):
									SCREAMING_SNAKE_CASE						:							List[str]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE     ,       revision='aaaaaa'    )





	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	List[Any]:





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'     ,       ):
									SCREAMING_SNAKE_CASE						:							int							=     AutoFeatureExtractor.from_pretrained('hf-internal-testing/config-no-model'    )





	def 			_lowerCAmelCase     (      self				:       Optional[Any]    )						->	str:





					"""simple docstring"""


					with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
									SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'    )
					# If remote code is disabled, we can't load this config.
					with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
									SCREAMING_SNAKE_CASE						:							int							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE						:							Optional[int]							=     AutoFeatureExtractor.from_pretrained(
					    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
					self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )

					# Test feature extractor can be reloaded.
					with tempfile.TemporaryDirectory() as tmp_dir:
									feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE						:							List[str]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
					self.assertEqual(reloaded_feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )





	def 			_lowerCAmelCase     (      self				:       Any    )						->	Optional[int]:





					"""simple docstring"""


					try:
									AutoConfig.register('custom'     ,       _SCREAMING_SNAKE_CASE    )
									AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
													AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )

									# Now that the config is registered, it can be used as any other config with the auto-API
									SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
									with tempfile.TemporaryDirectory() as tmp_dir:
													feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE    )
													SCREAMING_SNAKE_CASE						:							Dict							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
													self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )

					finally:
									if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
													del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]







	def 			_lowerCAmelCase     (      self				:       Tuple    )						->	str:





					"""simple docstring"""


					class     lowerCAmelCase__						(	_lowerCamelCase ):


						'''simple docstring'''







						_SCREAMING_SNAKE_CASE	:		str  						= True

					try:
									AutoConfig.register('custom'     ,       _SCREAMING_SNAKE_CASE    )
									AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									# If remote code is not set, the default is to use local
									SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(feature_extractor.is_local    )

									# If remote code is disabled, we load the local one.
									SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(feature_extractor.is_local    )

									# If remote is enabled, we load from the Hub
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(not hasattr(_SCREAMING_SNAKE_CASE     ,       'is_local'    )    )

					finally:
									if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
													del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]





