





"""simple docstring"""




import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


UpperCamelCase_									=logging.get_logger(__name__)

UpperCamelCase_									=OrderedDict(
    [
        ("""audio-spectrogram-transformer""", """ASTFeatureExtractor"""),
        ("""beit""", """BeitFeatureExtractor"""),
        ("""chinese_clip""", """ChineseCLIPFeatureExtractor"""),
        ("""clap""", """ClapFeatureExtractor"""),
        ("""clip""", """CLIPFeatureExtractor"""),
        ("""clipseg""", """ViTFeatureExtractor"""),
        ("""conditional_detr""", """ConditionalDetrFeatureExtractor"""),
        ("""convnext""", """ConvNextFeatureExtractor"""),
        ("""cvt""", """ConvNextFeatureExtractor"""),
        ("""data2vec-audio""", """Wav2Vec2FeatureExtractor"""),
        ("""data2vec-vision""", """BeitFeatureExtractor"""),
        ("""deformable_detr""", """DeformableDetrFeatureExtractor"""),
        ("""deit""", """DeiTFeatureExtractor"""),
        ("""detr""", """DetrFeatureExtractor"""),
        ("""dinat""", """ViTFeatureExtractor"""),
        ("""donut-swin""", """DonutFeatureExtractor"""),
        ("""dpt""", """DPTFeatureExtractor"""),
        ("""encodec""", """EncodecFeatureExtractor"""),
        ("""flava""", """FlavaFeatureExtractor"""),
        ("""glpn""", """GLPNFeatureExtractor"""),
        ("""groupvit""", """CLIPFeatureExtractor"""),
        ("""hubert""", """Wav2Vec2FeatureExtractor"""),
        ("""imagegpt""", """ImageGPTFeatureExtractor"""),
        ("""layoutlmv2""", """LayoutLMv2FeatureExtractor"""),
        ("""layoutlmv3""", """LayoutLMv3FeatureExtractor"""),
        ("""levit""", """LevitFeatureExtractor"""),
        ("""maskformer""", """MaskFormerFeatureExtractor"""),
        ("""mctct""", """MCTCTFeatureExtractor"""),
        ("""mobilenet_v1""", """MobileNetV1FeatureExtractor"""),
        ("""mobilenet_v2""", """MobileNetV2FeatureExtractor"""),
        ("""mobilevit""", """MobileViTFeatureExtractor"""),
        ("""nat""", """ViTFeatureExtractor"""),
        ("""owlvit""", """OwlViTFeatureExtractor"""),
        ("""perceiver""", """PerceiverFeatureExtractor"""),
        ("""poolformer""", """PoolFormerFeatureExtractor"""),
        ("""regnet""", """ConvNextFeatureExtractor"""),
        ("""resnet""", """ConvNextFeatureExtractor"""),
        ("""segformer""", """SegformerFeatureExtractor"""),
        ("""sew""", """Wav2Vec2FeatureExtractor"""),
        ("""sew-d""", """Wav2Vec2FeatureExtractor"""),
        ("""speech_to_text""", """Speech2TextFeatureExtractor"""),
        ("""speecht5""", """SpeechT5FeatureExtractor"""),
        ("""swiftformer""", """ViTFeatureExtractor"""),
        ("""swin""", """ViTFeatureExtractor"""),
        ("""swinv2""", """ViTFeatureExtractor"""),
        ("""table-transformer""", """DetrFeatureExtractor"""),
        ("""timesformer""", """VideoMAEFeatureExtractor"""),
        ("""tvlt""", """TvltFeatureExtractor"""),
        ("""unispeech""", """Wav2Vec2FeatureExtractor"""),
        ("""unispeech-sat""", """Wav2Vec2FeatureExtractor"""),
        ("""van""", """ConvNextFeatureExtractor"""),
        ("""videomae""", """VideoMAEFeatureExtractor"""),
        ("""vilt""", """ViltFeatureExtractor"""),
        ("""vit""", """ViTFeatureExtractor"""),
        ("""vit_mae""", """ViTFeatureExtractor"""),
        ("""vit_msn""", """ViTFeatureExtractor"""),
        ("""wav2vec2""", """Wav2Vec2FeatureExtractor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2FeatureExtractor"""),
        ("""wavlm""", """Wav2Vec2FeatureExtractor"""),
        ("""whisper""", """WhisperFeatureExtractor"""),
        ("""xclip""", """CLIPFeatureExtractor"""),
        ("""yolos""", """YolosFeatureExtractor"""),
    ]
)

UpperCamelCase_									=_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)





def 	a_    (							_lowercase       ):
						for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
												if class_name in extractors:
																		_UpperCamelCase      : int         =   model_type_to_module_name(lowerCAmelCase__       )

																		_UpperCamelCase      : str         =   importlib.import_module(F""".{module_name}"""	,						'''transformers.models'''       )
																		try:
																								return getattr(lowerCAmelCase__	,						lowerCAmelCase__       )
																		except AttributeError:
																								continue

						for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
												if getattr(lowerCAmelCase__	,						'''__name__'''	,						lowerCAmelCase__       ) == class_name:
																		return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
						_UpperCamelCase      : Tuple         =   importlib.import_module('''transformers'''       )
						if hasattr(lowerCAmelCase__	,						lowerCAmelCase__       ):
												return getattr(lowerCAmelCase__	,						lowerCAmelCase__       )

						return None





def 	a_    (							_lowercase	,						_lowercase = None	,						_lowercase = False	,						_lowercase = False	,						_lowercase = None	,						_lowercase = None	,						_lowercase = None	,						_lowercase = False	,						**_lowercase	,						):
						_UpperCamelCase      : Optional[Any]         =   get_file_from_repo(
						    lowerCAmelCase__	,						lowerCAmelCase__	,						cache_dir=lowerCAmelCase__	,						force_download=lowerCAmelCase__	,						resume_download=lowerCAmelCase__	,						proxies=lowerCAmelCase__	,						use_auth_token=lowerCAmelCase__	,						revision=lowerCAmelCase__	,						local_files_only=lowerCAmelCase__	,						)
						if resolved_config_file is None:
												logger.info(
												    '''Could not locate the feature extractor configuration file, will try to use the model config instead.'''       )
												return {}

						with open(lowerCAmelCase__	,						encoding='''utf-8'''       ) as reader:
												return json.load(lowerCAmelCase__       )






class 			_a						:






				def __init__(			self		:   Dict							)     ->				Optional[Any]:




										'''simple docstring'''



										raise EnvironmentError(
										    '''AutoFeatureExtractor is designed to be instantiated '''
										    '''using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method.'''							)






				@classmethod
				@replace_list_option_in_docstrings(_a							)
				def     snake_case     (			cls		:   int,			lowerCAmelCase__		:   Tuple,			**lowerCAmelCase__		:   List[Any]							)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   kwargs.pop('''config''',			_a							)
										_UpperCamelCase      : List[Any]         =   kwargs.pop('''trust_remote_code''',			_a							)
										_UpperCamelCase      : int         =   True

										_UpperCamelCase       ,							_UpperCamelCase      : int         =   FeatureExtractionMixin.get_feature_extractor_dict(_a,			**_a							)
										_UpperCamelCase      : Any         =   config_dict.get('''feature_extractor_type''',			_a							)
										_UpperCamelCase      : Any         =   None
										if "AutoFeatureExtractor" in config_dict.get('''auto_map''',			{}							):
																_UpperCamelCase      : Dict         =   config_dict['''auto_map''']['''AutoFeatureExtractor''']

										# If we don't find the feature extractor class in the feature extractor config, let's try the model config.
										if feature_extractor_class is None and feature_extractor_auto_map is None:
																if not isinstance(_a,			_a							):
																						_UpperCamelCase      : Optional[Any]         =   AutoConfig.from_pretrained(_a,			**_a							)
																# It could be in `config.feature_extractor_type``
																_UpperCamelCase      : List[Any]         =   getattr(_a,			'''feature_extractor_type''',			_a							)
																if hasattr(_a,			'''auto_map'''							) and "AutoFeatureExtractor" in config.auto_map:
																						_UpperCamelCase      : Any         =   config.auto_map['''AutoFeatureExtractor''']

										if feature_extractor_class is not None:
																_UpperCamelCase      : List[str]         =   feature_extractor_class_from_name(_a							)

										_UpperCamelCase      : List[str]         =   feature_extractor_auto_map is not None
										_UpperCamelCase      : Dict         =   feature_extractor_class is not None or type(_a							) in FEATURE_EXTRACTOR_MAPPING
										_UpperCamelCase      : str         =   resolve_trust_remote_code(
										    _a,			_a,			_a,			_a							)

										if has_remote_code and trust_remote_code:
																_UpperCamelCase      : str         =   get_class_from_dynamic_module(
																    _a,			_a,			**_a							)
																_UpperCamelCase      : str         =   kwargs.pop('''code_revision''',			_a							)
																if os.path.isdir(_a							):
																						feature_extractor_class.register_for_auto_class()
																return feature_extractor_class.from_dict(_a,			**_a							)
										elif feature_extractor_class is not None:
																return feature_extractor_class.from_dict(_a,			**_a							)
										# Last try: we use the FEATURE_EXTRACTOR_MAPPING.
										elif type(_a							) in FEATURE_EXTRACTOR_MAPPING:
																_UpperCamelCase      : Any         =   FEATURE_EXTRACTOR_MAPPING[type(_a							)]
																return feature_extractor_class.from_dict(_a,			**_a							)

										raise ValueError(
										    f"""Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a """
										    f"""`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following """
										    f"""`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()							)}"""							)






				@staticmethod
				def     snake_case     (			lowerCAmelCase__		:   Union[str, Any],			lowerCAmelCase__		:   List[Any]							)     ->				Optional[Any]:




										'''simple docstring'''



										FEATURE_EXTRACTOR_MAPPING.register(_a,			_a							)










"""simple docstring"""




import argparse

import torch

from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
from transformers.utils import logging


logging.set_verbosity_info()





def 	a_    (							_lowercase	,						_lowercase	,						_lowercase       ):
						# Initialise PyTorch model
						_UpperCamelCase      : List[Any]         =   MobileBertConfig.from_json_file(_lowercase       )
						print(F"""Building PyTorch model from configuration: {config}"""       )
						_UpperCamelCase      : List[str]         =   MobileBertForPreTraining(_lowercase       )
						# Load weights from tf checkpoint
						_UpperCamelCase      : Union[str, Any]         =   load_tf_weights_in_mobilebert(_lowercase	,						_lowercase	,						_lowercase       )
						# Save pytorch-model
						print(F"""Save PyTorch model to {pytorch_dump_path}"""       )
						torch.save(model.state_dict()	,						_lowercase       )


if __name__ == "__main__":
						UpperCamelCase_									=argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
						)
						parser.add_argument(
						    """--mobilebert_config_file""",
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        """The config json file corresponding to the pre-trained MobileBERT model. \n"""
						        """This specifies the model architecture."""
						    ),
						)
						parser.add_argument(
						    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
						)
						UpperCamelCase_									=parser.parse_args()
						convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)



