

import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)







def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase    ):
						SCREAMING_SNAKE_CASE_: List[str]  		=       XCLIPTextConfig()

						# derive patch size from model name
						SCREAMING_SNAKE_CASE_: int  		=       model_name.find("patch"    )
						SCREAMING_SNAKE_CASE_: List[str]  		=       int(model_name[start_idx + len("patch"    ) : start_idx + len("patch"    ) + 2]    )
						SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       XCLIPVisionConfig(patch_size=_UpperCAmelCase				,	num_frames=_UpperCAmelCase    )

						if "large" in model_name:
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       7_68
												SCREAMING_SNAKE_CASE_: List[str]  		=       30_72
												SCREAMING_SNAKE_CASE_: str  		=       12

												SCREAMING_SNAKE_CASE_: int  		=       10_24
												SCREAMING_SNAKE_CASE_: List[Any]  		=       40_96
												SCREAMING_SNAKE_CASE_: str  		=       16
												SCREAMING_SNAKE_CASE_: Dict  		=       24
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       7_68
												SCREAMING_SNAKE_CASE_: Any  		=       30_72

						if model_name == "xclip-large-patch14-16-frames":
												SCREAMING_SNAKE_CASE_: List[Any]  		=       3_36

						SCREAMING_SNAKE_CASE_: Optional[int]  		=       XCLIPConfig.from_text_vision_configs(_UpperCAmelCase				,	_UpperCAmelCase    )

						if "large" in model_name:
												SCREAMING_SNAKE_CASE_: Optional[int]  		=       7_68

						return config







def 			A_      (    _UpperCAmelCase    ):
						# text encoder
						if name == "token_embedding.weight":
												SCREAMING_SNAKE_CASE_: int  		=       name.replace("token_embedding.weight"				,	"text_model.embeddings.token_embedding.weight"    )
						if name == "positional_embedding":
												SCREAMING_SNAKE_CASE_: Any  		=       name.replace("positional_embedding"				,	"text_model.embeddings.position_embedding.weight"    )
						if "ln_1" in name:
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       name.replace("ln_1"				,	"layer_norm1"    )
						if "ln_2" in name:
												SCREAMING_SNAKE_CASE_: List[str]  		=       name.replace("ln_2"				,	"layer_norm2"    )
						if "c_fc" in name:
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       name.replace("c_fc"				,	"fc1"    )
						if "c_proj" in name:
												SCREAMING_SNAKE_CASE_: Dict  		=       name.replace("c_proj"				,	"fc2"    )
						if name.startswith("transformer.resblocks"    ):
												SCREAMING_SNAKE_CASE_: Any  		=       name.replace("transformer.resblocks"				,	"text_model.encoder.layers"    )
						if "attn.out_proj" in name and "message" not in name:
												SCREAMING_SNAKE_CASE_: str  		=       name.replace("attn.out_proj"				,	"self_attn.out_proj"    )
						if "ln_final" in name:
												SCREAMING_SNAKE_CASE_: int  		=       name.replace("ln_final"				,	"text_model.final_layer_norm"    )
						# visual encoder
						if name == "visual.class_embedding":
												SCREAMING_SNAKE_CASE_: Optional[int]  		=       name.replace("visual.class_embedding"				,	"vision_model.embeddings.class_embedding"    )
						if name == "visual.positional_embedding":
												SCREAMING_SNAKE_CASE_: int  		=       name.replace("visual.positional_embedding"				,	"vision_model.embeddings.position_embedding.weight"    )
						if name.startswith("visual.transformer.resblocks"    ):
												SCREAMING_SNAKE_CASE_: str  		=       name.replace("visual.transformer.resblocks"				,	"vision_model.encoder.layers"    )
						if "visual.conv1" in name:
												SCREAMING_SNAKE_CASE_: List[Any]  		=       name.replace("visual.conv1"				,	"vision_model.embeddings.patch_embedding"    )
						if "visual.ln_pre" in name:
												SCREAMING_SNAKE_CASE_: Tuple  		=       name.replace("visual.ln_pre"				,	"vision_model.pre_layernorm"    )
						if "visual.ln_post" in name:
												SCREAMING_SNAKE_CASE_: Any  		=       name.replace("visual.ln_post"				,	"vision_model.post_layernorm"    )
						if "visual.proj" in name:
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       name.replace("visual.proj"				,	"visual_projection.weight"    )
						if "text_projection" in name:
												SCREAMING_SNAKE_CASE_: Dict  		=       name.replace("text_projection"				,	"text_projection.weight"    )
						# things on top
						if "prompts_visual_proj" in name:
												SCREAMING_SNAKE_CASE_: List[Any]  		=       name.replace("prompts_visual_proj"				,	"prompts_visual_projection"    )
						if "prompts_visual_ln" in name:
												SCREAMING_SNAKE_CASE_: List[Any]  		=       name.replace("prompts_visual_ln"				,	"prompts_visual_layernorm"    )
						# mit
						if name == "mit.positional_embedding":
												SCREAMING_SNAKE_CASE_: str  		=       name.replace("positional"				,	"position"    )
						if name.startswith("mit.resblocks"    ):
												SCREAMING_SNAKE_CASE_: Optional[int]  		=       name.replace("mit.resblocks"				,	"mit.encoder.layers"    )
						# prompts generator
						if name.startswith("prompts_generator.norm"    ):
												SCREAMING_SNAKE_CASE_: Tuple  		=       name.replace("prompts_generator.norm"				,	"prompts_generator.layernorm"    )

						return name







def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase    ):
						for key in orig_state_dict.copy().keys():
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       orig_state_dict.pop(_UpperCAmelCase    )

												if "attn.in_proj" in key:
																		SCREAMING_SNAKE_CASE_: Optional[int]  		=       key.split("."    )
																		if key.startswith("visual"    ):
																								SCREAMING_SNAKE_CASE_: Optional[int]  		=       key_split[3]
																								SCREAMING_SNAKE_CASE_: Dict  		=       config.vision_config.hidden_size
																								if "message_attn" in key:
																														if "weight" in key:
																																				SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       val[
																																				    :dim, :
																																				]
																																				SCREAMING_SNAKE_CASE_: Dict  		=       val[
																																				    dim : dim * 2, :
																																				]
																																				SCREAMING_SNAKE_CASE_: Any  		=       val[
																																				    -dim:, :
																																				]
																														else:
																																				SCREAMING_SNAKE_CASE_: Dict  		=       val[
																																				    :dim
																																				]
																																				SCREAMING_SNAKE_CASE_: Optional[Any]  		=       val[
																																				    dim : dim * 2
																																				]
																																				SCREAMING_SNAKE_CASE_: List[Any]  		=       val[
																																				    -dim:
																																				]
																								else:
																														if "weight" in key:
																																				SCREAMING_SNAKE_CASE_: List[str]  		=       val[
																																				    :dim, :
																																				]
																																				SCREAMING_SNAKE_CASE_: str  		=       val[
																																				    dim : dim * 2, :
																																				]
																																				SCREAMING_SNAKE_CASE_: int  		=       val[
																																				    -dim:, :
																																				]
																														else:
																																				SCREAMING_SNAKE_CASE_: Dict  		=       val[:dim]
																																				SCREAMING_SNAKE_CASE_: int  		=       val[
																																				    dim : dim * 2
																																				]
																																				SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       val[-dim:]
																		elif key.startswith("mit"    ):
																								SCREAMING_SNAKE_CASE_: List[Any]  		=       key_split[2]
																								SCREAMING_SNAKE_CASE_: Tuple  		=       config.vision_config.mit_hidden_size
																								if "weight" in key:
																														SCREAMING_SNAKE_CASE_: Tuple  		=       val[:dim, :]
																														SCREAMING_SNAKE_CASE_: Dict  		=       val[dim : dim * 2, :]
																														SCREAMING_SNAKE_CASE_: Optional[int]  		=       val[-dim:, :]
																								else:
																														SCREAMING_SNAKE_CASE_: List[Any]  		=       val[:dim]
																														SCREAMING_SNAKE_CASE_: List[str]  		=       val[dim : dim * 2]
																														SCREAMING_SNAKE_CASE_: str  		=       val[-dim:]
																		else:
																								SCREAMING_SNAKE_CASE_: Any  		=       key_split[2]
																								SCREAMING_SNAKE_CASE_: Optional[Any]  		=       config.text_config.hidden_size
																								if "weight" in key:
																														SCREAMING_SNAKE_CASE_: List[str]  		=       val[:dim, :]
																														SCREAMING_SNAKE_CASE_: List[Any]  		=       val[
																														    dim : dim * 2, :
																														]
																														SCREAMING_SNAKE_CASE_: List[str]  		=       val[-dim:, :]
																								else:
																														SCREAMING_SNAKE_CASE_: Tuple  		=       val[:dim]
																														SCREAMING_SNAKE_CASE_: List[str]  		=       val[
																														    dim : dim * 2
																														]
																														SCREAMING_SNAKE_CASE_: Optional[Any]  		=       val[-dim:]
												else:
																		SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       rename_key(_UpperCAmelCase    )
																		if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
																								SCREAMING_SNAKE_CASE_: Dict  		=       val.T
																		SCREAMING_SNAKE_CASE_: Any  		=       val

						return orig_state_dict







def 			A_      (    _UpperCAmelCase    ):
						if num_frames == 8:
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       "eating_spaghetti_8_frames.npy"
						elif num_frames == 16:
												SCREAMING_SNAKE_CASE_: str  		=       "eating_spaghetti.npy"
						elif num_frames == 32:
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       "eating_spaghetti_32_frames.npy"
						SCREAMING_SNAKE_CASE_: List[Any]  		=       hf_hub_download(
						    repo_id="hf-internal-testing/spaghetti-video"				,	filename=_UpperCAmelCase				,	repo_type="dataset"				,	)
						SCREAMING_SNAKE_CASE_: str  		=       np.load(_UpperCAmelCase    )
						return list(_UpperCAmelCase    )







def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase=None				,	_UpperCAmelCase=False    ):
						SCREAMING_SNAKE_CASE_: Optional[Any]  		=       {
						    # fully supervised kinetics-400 checkpoints
						    "xclip-base-patch32": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth",
						    "xclip-base-patch32-16-frames": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"
						    ),
						    "xclip-base-patch16": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth",
						    "xclip-base-patch16-16-frames": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"
						    ),
						    "xclip-large-patch14": "https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb",
						    "xclip-large-patch14-16-frames": "https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f",
						    # fully supervised kinetics-600 checkpoints
						    "xclip-base-patch16-kinetics-600": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"
						    ),
						    "xclip-base-patch16-kinetics-600-16-frames": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"
						    ),
						    "xclip-large-patch14-kinetics-600": "https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be",
						    # few shot
						    "xclip-base-patch16-hmdb-2-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"
						    ),
						    "xclip-base-patch16-hmdb-4-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"
						    ),
						    "xclip-base-patch16-hmdb-8-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"
						    ),
						    "xclip-base-patch16-hmdb-16-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"
						    ),
						    "xclip-base-patch16-ucf-2-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"
						    ),
						    "xclip-base-patch16-ucf-4-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"
						    ),
						    "xclip-base-patch16-ucf-8-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"
						    ),
						    "xclip-base-patch16-ucf-16-shot": (
						        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"
						    ),
						    # zero shot
						    "xclip-base-patch16-zero-shot": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth",
						}

						SCREAMING_SNAKE_CASE_: Tuple  		=       model_to_url[model_name]
						SCREAMING_SNAKE_CASE_: int  		=       8
						if "16-frames" in model_name:
												SCREAMING_SNAKE_CASE_: int  		=       16
						elif "shot" in model_name:
												SCREAMING_SNAKE_CASE_: int  		=       32

						SCREAMING_SNAKE_CASE_: int  		=       get_xclip_config(_UpperCAmelCase				,	_UpperCAmelCase    )
						SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       XCLIPModel(_UpperCAmelCase    )
						model.eval()

						if "drive" in checkpoint_url:
												SCREAMING_SNAKE_CASE_: List[str]  		=       "pytorch_model.bin"
												gdown.cached_download(_UpperCAmelCase				,	_UpperCAmelCase				,	quiet=_UpperCAmelCase    )
												SCREAMING_SNAKE_CASE_: Tuple  		=       torch.load(_UpperCAmelCase				,	map_location="cpu"    )["model"]
						else:
												SCREAMING_SNAKE_CASE_: str  		=       torch.hub.load_state_dict_from_url(_UpperCAmelCase    )["model"]

						SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       convert_state_dict(_UpperCAmelCase				,	_UpperCAmelCase    )

						SCREAMING_SNAKE_CASE_: List[Any]  		=       XCLIPModel(_UpperCAmelCase    )
						SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_: Dict  		=       model.load_state_dict(_UpperCAmelCase				,	strict=_UpperCAmelCase    )
						assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
						model.eval()

						SCREAMING_SNAKE_CASE_: Optional[int]  		=       3_36 if model_name == "xclip-large-patch14-16-frames" else 2_24
						SCREAMING_SNAKE_CASE_: int  		=       VideoMAEImageProcessor(size=_UpperCAmelCase    )
						SCREAMING_SNAKE_CASE_: Optional[int]  		=       CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"    )
						SCREAMING_SNAKE_CASE_: Tuple  		=       CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32"    )
						SCREAMING_SNAKE_CASE_: Optional[Any]  		=       XCLIPProcessor(image_processor=_UpperCAmelCase				,	tokenizer=_UpperCAmelCase    )

						SCREAMING_SNAKE_CASE_: int  		=       prepare_video(_UpperCAmelCase    )
						SCREAMING_SNAKE_CASE_: List[Any]  		=       processor(
						    text=["playing sports", "eating spaghetti", "go shopping"]				,	videos=_UpperCAmelCase				,	return_tensors="pt"				,	padding=_UpperCAmelCase    )

						print("Shape of pixel values:"				,	inputs.pixel_values.shape    )

						with torch.no_grad():
												SCREAMING_SNAKE_CASE_: List[str]  		=       model(**_UpperCAmelCase    )

						# Verify outputs
						SCREAMING_SNAKE_CASE_: Any  		=       outputs.logits_per_video
						SCREAMING_SNAKE_CASE_: str  		=       logits_per_video.softmax(dim=1    )
						print("Probs:"				,	_UpperCAmelCase    )
						# kinetics-400
						if model_name == "xclip-base-patch32":
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       torch.tensor([[0.0_0_1_9, 0.9_9_5_1, 0.0_0_3_0]]    )
						elif model_name == "xclip-base-patch32-16-frames":
												SCREAMING_SNAKE_CASE_: Any  		=       torch.tensor([[7.0_999e-04, 9.9_883e-01, 4.5_580e-04]]    )
						elif model_name == "xclip-base-patch16":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[0.0_0_8_3, 0.9_6_8_1, 0.0_2_3_6]]    )
						elif model_name == "xclip-base-patch16-16-frames":
												SCREAMING_SNAKE_CASE_: Dict  		=       torch.tensor([[7.6_937e-04, 9.9_728e-01, 1.9_473e-03]]    )
						elif model_name == "xclip-large-patch14":
												SCREAMING_SNAKE_CASE_: Optional[int]  		=       torch.tensor([[0.0_0_6_2, 0.9_8_6_4, 0.0_0_7_5]]    )
						elif model_name == "xclip-large-patch14-16-frames":
												SCREAMING_SNAKE_CASE_: List[Any]  		=       torch.tensor([[3.3_877e-04, 9.9_937e-01, 2.8_888e-04]]    )
						# kinetics-600
						elif model_name == "xclip-base-patch16-kinetics-600":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[0.0_5_5_5, 0.8_9_1_4, 0.0_5_3_1]]    )
						elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[3.8_554e-04, 9.9_929e-01, 3.2_754e-04]]    )
						elif model_name == "xclip-large-patch14-kinetics-600":
												SCREAMING_SNAKE_CASE_: List[Any]  		=       torch.tensor([[0.0_0_3_6, 0.9_9_2_0, 0.0_0_4_5]]    )
						# few shot
						elif model_name == "xclip-base-patch16-hmdb-2-shot":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[7.1_890e-06, 9.9_994e-01, 5.6_559e-05]]    )
						elif model_name == "xclip-base-patch16-hmdb-4-shot":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[1.0_320e-05, 9.9_993e-01, 6.2_435e-05]]    )
						elif model_name == "xclip-base-patch16-hmdb-8-shot":
												SCREAMING_SNAKE_CASE_: Optional[Any]  		=       torch.tensor([[4.1_377e-06, 9.9_990e-01, 9.8_386e-05]]    )
						elif model_name == "xclip-base-patch16-hmdb-16-shot":
												SCREAMING_SNAKE_CASE_: List[Any]  		=       torch.tensor([[4.1_347e-05, 9.9_962e-01, 3.3_411e-04]]    )
						elif model_name == "xclip-base-patch16-ucf-2-shot":
												SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]]    )
						elif model_name == "xclip-base-patch16-ucf-4-shot":
												SCREAMING_SNAKE_CASE_: List[str]  		=       torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]]    )
						elif model_name == "xclip-base-patch16-ucf-8-shot":
												SCREAMING_SNAKE_CASE_: List[str]  		=       torch.tensor([[0.0_0_2_7, 0.9_9_0_4, 0.0_0_7_0]]    )
						elif model_name == "xclip-base-patch16-ucf-16-shot":
												SCREAMING_SNAKE_CASE_: Tuple  		=       torch.tensor([[9.8_219e-04, 9.9_593e-01, 3.0_863e-03]]    )
						# zero shot
						elif model_name == "xclip-base-patch16-zero-shot":
												SCREAMING_SNAKE_CASE_: int  		=       torch.tensor([[3.5_082e-04, 9.9_785e-01, 1.7_966e-03]]    )
						else:
												raise ValueError(f"Model name {model_name} not supported"    )
						assert torch.allclose(_UpperCAmelCase				,	_UpperCAmelCase				,	atol=1e-3    )
						print("Looks ok!"    )

						if pytorch_dump_folder_path is not None:
												print(f"Saving model {model_name} to {pytorch_dump_folder_path}"    )
												model.save_pretrained(_UpperCAmelCase    )

						if push_to_hub:
												print("Pushing model, processor and slow tokenizer files to the hub..."    )
												model.push_to_hub(_UpperCAmelCase				,	organization="nielsr"    )
												processor.push_to_hub(_UpperCAmelCase				,	organization="nielsr"    )
												slow_tokenizer.push_to_hub(_UpperCAmelCase				,	organization="nielsr"    )


if __name__ == "__main__":
						lowerCAmelCase							:  str   	=						argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    """--model_name""",
						    default="""xclip-base-patch32""",
						    type=str,
						    help="""Name of the model.""",
						)
						parser.add_argument(
						    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
						)
						parser.add_argument(
						    """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
						)

						lowerCAmelCase							:  Dict   	=						parser.parse_args()
						convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)












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,
)


_snake_case										=       logging.get_logger(__name__)

_snake_case										=       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"),
    ]
)

_snake_case										=       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)







def 				lowerCAmelCase_	(     snake_case_     ):
      for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  _A							:     List[str]			=						model_type_to_module_name(snake_case_     )

                  _A							:     List[Any]			=						importlib.import_module(f'''.{module_name}''',"""transformers.models"""     )
                  try:
                        return getattr(snake_case_,snake_case_     )
                  except AttributeError:
                        continue

      for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
            if getattr(snake_case_,"""__name__""",snake_case_     ) == 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.
      _A							:     List[Any]			=						importlib.import_module("""transformers"""     )
      if hasattr(snake_case_,snake_case_     ):
            return getattr(snake_case_,snake_case_     )

      return None







def 				lowerCAmelCase_	(     snake_case_,snake_case_ = None,snake_case_ = False,snake_case_ = False,snake_case_ = None,snake_case_ = None,snake_case_ = None,snake_case_ = False,**snake_case_,):
      _A							:     Optional[int]			=						get_file_from_repo(
          snake_case_,snake_case_,cache_dir=snake_case_,force_download=snake_case_,resume_download=snake_case_,proxies=snake_case_,use_auth_token=snake_case_,revision=snake_case_,local_files_only=snake_case_,)
      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(snake_case_,encoding="""utf-8"""     ) as reader:
            return json.load(snake_case_     )







class 						lowercase							:

     def __init__(  self				)						->							List[Any]:
           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 					a__	(  cls		,     _a		,     **_a				)						->							Any:
           _A							:     Tuple			=						kwargs.pop("""config"""		,     _a				)
           _A							:     Tuple			=						kwargs.pop("""trust_remote_code"""		,     _a				)
           _A							:     List[Any]			=						True

           _A			,   _A							:     Tuple			=						FeatureExtractionMixin.get_feature_extractor_dict(_a		,     **_a				)
           _A							:     Tuple			=						config_dict.get("""feature_extractor_type"""		,     _a				)
           _A							:     int			=						None
           if "AutoFeatureExtractor" in config_dict.get("""auto_map"""		,     {}				):
                 _A							:     Optional[int]			=						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				):
                       _A							:     int			=						AutoConfig.from_pretrained(_a		,     **_a				)
                 # It could be in `config.feature_extractor_type``
                 _A							:     Optional[int]			=						getattr(_a		,     """feature_extractor_type"""		,     _a				)
                 if hasattr(_a		,     """auto_map"""				) and "AutoFeatureExtractor" in config.auto_map:
                       _A							:     Tuple			=						config.auto_map["""AutoFeatureExtractor"""]

           if feature_extractor_class is not None:
                 _A							:     Optional[Any]			=						feature_extractor_class_from_name(_a				)

           _A							:     List[Any]			=						feature_extractor_auto_map is not None
           _A							:     Union[str, Any]			=						feature_extractor_class is not None or type(_a				) in FEATURE_EXTRACTOR_MAPPING
           _A							:     Optional[int]			=						resolve_trust_remote_code(
               _a		,     _a		,     _a		,     _a				)

           if has_remote_code and trust_remote_code:
                 _A							:     Dict			=						get_class_from_dynamic_module(
                     _a		,     _a		,     **_a				)
                 _A							:     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:
                 _A							:     Dict			=						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 					a__	(  _a		,     _a				)						->							Optional[int]:
           FEATURE_EXTRACTOR_MAPPING.register(_a		,     _a				)

