


"""simple docstring"""




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_ (	lowercase__ :List[Any],			lowercase__ :Tuple     ):
			__lowerCamelCase          =      XCLIPTextConfig()

			# derive patch size from model name
			__lowerCamelCase          =      model_name.find("""patch"""     )
			__lowerCamelCase          =      int(model_name[start_idx + len("""patch"""     ) : start_idx + len("""patch"""     ) + 2]     )
			__lowerCamelCase          =      XCLIPVisionConfig(patch_size=lowercase__,			num_frames=lowercase__     )

			if "large" in model_name:
						__lowerCamelCase          =      768
						__lowerCamelCase          =      3072
						__lowerCamelCase          =      12

						__lowerCamelCase          =      1024
						__lowerCamelCase          =      4096
						__lowerCamelCase          =      16
						__lowerCamelCase          =      24
						__lowerCamelCase          =      768
						__lowerCamelCase          =      3072

			if model_name == "xclip-large-patch14-16-frames":
						__lowerCamelCase          =      336

			__lowerCamelCase          =      XCLIPConfig.from_text_vision_configs(lowercase__,			lowercase__     )

			if "large" in model_name:
						__lowerCamelCase          =      768

			return config





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

			return name





def       a_ (	lowercase__ :int,			lowercase__ :Dict     ):
			for key in orig_state_dict.copy().keys():
						__lowerCamelCase          =      orig_state_dict.pop(lowercase__     )

						if "attn.in_proj" in key:
									__lowerCamelCase          =      key.split("""."""     )
									if key.startswith("""visual"""     ):
												__lowerCamelCase          =      key_split[3]
												__lowerCamelCase          =      config.vision_config.hidden_size
												if "message_attn" in key:
															if "weight" in key:
																		__lowerCamelCase          =      val[
																		    :dim, :
																		]
																		__lowerCamelCase          =      val[
																		    dim : dim * 2, :
																		]
																		__lowerCamelCase          =      val[
																		    -dim:, :
																		]
															else:
																		__lowerCamelCase          =      val[
																		    :dim
																		]
																		__lowerCamelCase          =      val[
																		    dim : dim * 2
																		]
																		__lowerCamelCase          =      val[
																		    -dim:
																		]
												else:
															if "weight" in key:
																		__lowerCamelCase          =      val[
																		    :dim, :
																		]
																		__lowerCamelCase          =      val[
																		    dim : dim * 2, :
																		]
																		__lowerCamelCase          =      val[
																		    -dim:, :
																		]
															else:
																		__lowerCamelCase          =      val[:dim]
																		__lowerCamelCase          =      val[
																		    dim : dim * 2
																		]
																		__lowerCamelCase          =      val[-dim:]
									elif key.startswith("""mit"""     ):
												__lowerCamelCase          =      key_split[2]
												__lowerCamelCase          =      config.vision_config.mit_hidden_size
												if "weight" in key:
															__lowerCamelCase          =      val[:dim, :]
															__lowerCamelCase          =      val[dim : dim * 2, :]
															__lowerCamelCase          =      val[-dim:, :]
												else:
															__lowerCamelCase          =      val[:dim]
															__lowerCamelCase          =      val[dim : dim * 2]
															__lowerCamelCase          =      val[-dim:]
									else:
												__lowerCamelCase          =      key_split[2]
												__lowerCamelCase          =      config.text_config.hidden_size
												if "weight" in key:
															__lowerCamelCase          =      val[:dim, :]
															__lowerCamelCase          =      val[
															    dim : dim * 2, :
															]
															__lowerCamelCase          =      val[-dim:, :]
												else:
															__lowerCamelCase          =      val[:dim]
															__lowerCamelCase          =      val[
															    dim : dim * 2
															]
															__lowerCamelCase          =      val[-dim:]
						else:
									__lowerCamelCase          =      rename_key(lowercase__     )
									if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
												__lowerCamelCase          =      val.T
									__lowerCamelCase          =      val

			return orig_state_dict





def       a_ (	lowercase__ :Dict     ):
			if num_frames == 8:
						__lowerCamelCase          =      """eating_spaghetti_8_frames.npy"""
			elif num_frames == 16:
						__lowerCamelCase          =      """eating_spaghetti.npy"""
			elif num_frames == 32:
						__lowerCamelCase          =      """eating_spaghetti_32_frames.npy"""
			__lowerCamelCase          =      hf_hub_download(
			    repo_id="""hf-internal-testing/spaghetti-video""",			filename=lowercase__,			repo_type="""dataset""",			)
			__lowerCamelCase          =      np.load(lowercase__     )
			return list(lowercase__     )





def       a_ (	lowercase__ :List[Any],			lowercase__ :int=None,			lowercase__ :Dict=False     ):
			__lowerCamelCase          =      {
			    # 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""",
			}

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

			__lowerCamelCase          =      get_xclip_config(lowercase__,			lowercase__     )
			__lowerCamelCase          =      XCLIPModel(lowercase__     )
			model.eval()

			if "drive" in checkpoint_url:
						__lowerCamelCase          =      """pytorch_model.bin"""
						gdown.cached_download(lowercase__,			lowercase__,			quiet=lowercase__     )
						__lowerCamelCase          =      torch.load(lowercase__,			map_location="""cpu"""     )["""model"""]
			else:
						__lowerCamelCase          =      torch.hub.load_state_dict_from_url(lowercase__     )["""model"""]

			__lowerCamelCase          =      convert_state_dict(lowercase__,			lowercase__     )

			__lowerCamelCase          =      XCLIPModel(lowercase__     )
			__lowerCamelCase     ,__lowerCamelCase          =      model.load_state_dict(lowercase__,			strict=lowercase__     )
			assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
			model.eval()

			__lowerCamelCase          =      336 if model_name == """xclip-large-patch14-16-frames""" else 224
			__lowerCamelCase          =      VideoMAEImageProcessor(size=lowercase__     )
			__lowerCamelCase          =      CLIPTokenizer.from_pretrained("""openai/clip-vit-base-patch32"""     )
			__lowerCamelCase          =      CLIPTokenizerFast.from_pretrained("""openai/clip-vit-base-patch32"""     )
			__lowerCamelCase          =      XCLIPProcessor(image_processor=lowercase__,			tokenizer=lowercase__     )

			__lowerCamelCase          =      prepare_video(lowercase__     )
			__lowerCamelCase          =      processor(
			    text=["""playing sports""", """eating spaghetti""", """go shopping"""],			videos=lowercase__,			return_tensors="""pt""",			padding=lowercase__     )

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

			with torch.no_grad():
						__lowerCamelCase          =      model(**lowercase__     )

			# Verify outputs
			__lowerCamelCase          =      outputs.logits_per_video
			__lowerCamelCase          =      logits_per_video.softmax(dim=1     )
			print("""Probs:""",			lowercase__     )
			# kinetics-400
			if model_name == "xclip-base-patch32":
						__lowerCamelCase          =      torch.tensor([[0.0019, 0.9951, 0.0030]]     )
			elif model_name == "xclip-base-patch32-16-frames":
						__lowerCamelCase          =      torch.tensor([[7.0_999e-04, 9.9_883e-01, 4.5_580e-04]]     )
			elif model_name == "xclip-base-patch16":
						__lowerCamelCase          =      torch.tensor([[0.0083, 0.9681, 0.0236]]     )
			elif model_name == "xclip-base-patch16-16-frames":
						__lowerCamelCase          =      torch.tensor([[7.6_937e-04, 9.9_728e-01, 1.9_473e-03]]     )
			elif model_name == "xclip-large-patch14":
						__lowerCamelCase          =      torch.tensor([[0.0062, 0.9864, 0.0075]]     )
			elif model_name == "xclip-large-patch14-16-frames":
						__lowerCamelCase          =      torch.tensor([[3.3_877e-04, 9.9_937e-01, 2.8_888e-04]]     )
			# kinetics-600
			elif model_name == "xclip-base-patch16-kinetics-600":
						__lowerCamelCase          =      torch.tensor([[0.0555, 0.8914, 0.0531]]     )
			elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
						__lowerCamelCase          =      torch.tensor([[3.8_554e-04, 9.9_929e-01, 3.2_754e-04]]     )
			elif model_name == "xclip-large-patch14-kinetics-600":
						__lowerCamelCase          =      torch.tensor([[0.0036, 0.9920, 0.0045]]     )
			# few shot
			elif model_name == "xclip-base-patch16-hmdb-2-shot":
						__lowerCamelCase          =      torch.tensor([[7.1_890e-06, 9.9_994e-01, 5.6_559e-05]]     )
			elif model_name == "xclip-base-patch16-hmdb-4-shot":
						__lowerCamelCase          =      torch.tensor([[1.0_320e-05, 9.9_993e-01, 6.2_435e-05]]     )
			elif model_name == "xclip-base-patch16-hmdb-8-shot":
						__lowerCamelCase          =      torch.tensor([[4.1_377e-06, 9.9_990e-01, 9.8_386e-05]]     )
			elif model_name == "xclip-base-patch16-hmdb-16-shot":
						__lowerCamelCase          =      torch.tensor([[4.1_347e-05, 9.9_962e-01, 3.3_411e-04]]     )
			elif model_name == "xclip-base-patch16-ucf-2-shot":
						__lowerCamelCase          =      torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]]     )
			elif model_name == "xclip-base-patch16-ucf-4-shot":
						__lowerCamelCase          =      torch.tensor([[8.5_857e-05, 9.9_928e-01, 6.3_291e-04]]     )
			elif model_name == "xclip-base-patch16-ucf-8-shot":
						__lowerCamelCase          =      torch.tensor([[0.0027, 0.9904, 0.0070]]     )
			elif model_name == "xclip-base-patch16-ucf-16-shot":
						__lowerCamelCase          =      torch.tensor([[9.8_219e-04, 9.9_593e-01, 3.0_863e-03]]     )
			# zero shot
			elif model_name == "xclip-base-patch16-zero-shot":
						__lowerCamelCase          =      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(lowercase__,			lowercase__,			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(lowercase__     )

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


if __name__ == "__main__":
					__magic_name__						: List[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.'
					)

					__magic_name__						: int    =				parser.parse_args()
					convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








"""simple docstring"""




import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType




class 			__snake_case   (lowerCamelCase  ):
							__a					 =       ['''image_processor''', '''tokenizer''']
							__a					 =       '''LayoutLMv2ImageProcessor'''
							__a					 =       ('''LayoutXLMTokenizer''', '''LayoutXLMTokenizerFast''')




							def __init__(     self:    Any     ,							A_:    Optional[Any]=None     ,							A_:    Dict=None     ,							**A_:    Any   ):
										if "feature_extractor" in kwargs:
													warnings.warn(
													    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
													    """ instead."""     ,							A_     ,							)
													__lowerCamelCase          =      kwargs.pop("""feature_extractor"""   )

										__lowerCamelCase          =      image_processor if image_processor is not None else feature_extractor
										if image_processor is None:
													raise ValueError("""You need to specify an `image_processor`."""   )
										if tokenizer is None:
													raise ValueError("""You need to specify a `tokenizer`."""   )

										super().__init__(A_     ,							A_   )




							def __call__(     self:    List[str]     ,							A_:    Any     ,							A_:    Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None     ,							A_:    Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None     ,							A_:    Union[List[List[int]], List[List[List[int]]]] = None     ,							A_:    Optional[Union[List[int], List[List[int]]]] = None     ,							A_:    bool = True     ,							A_:    Union[bool, str, PaddingStrategy] = False     ,							A_:    Union[bool, str, TruncationStrategy] = None     ,							A_:    Optional[int] = None     ,							A_:    int = 0     ,							A_:    Optional[int] = None     ,							A_:    Optional[bool] = None     ,							A_:    Optional[bool] = None     ,							A_:    bool = False     ,							A_:    bool = False     ,							A_:    bool = False     ,							A_:    bool = False     ,							A_:    bool = True     ,							A_:    Optional[Union[str, TensorType]] = None     ,							**A_:    Any     ,							):
										# verify input
										if self.image_processor.apply_ocr and (boxes is not None):
													raise ValueError(
													    """You cannot provide bounding boxes """
													    """if you initialized the image processor with apply_ocr set to True."""   )

										if self.image_processor.apply_ocr and (word_labels is not None):
													raise ValueError(
													    """You cannot provide word labels if you initialized the image processor with apply_ocr set to True."""   )

										if return_overflowing_tokens is True and return_offsets_mapping is False:
													raise ValueError("""You cannot return overflowing tokens without returning the offsets mapping."""   )

										# first, apply the image processor
										__lowerCamelCase          =      self.image_processor(images=A_     ,							return_tensors=A_   )

										# second, apply the tokenizer
										if text is not None and self.image_processor.apply_ocr and text_pair is None:
													if isinstance(A_     ,							A_   ):
																__lowerCamelCase          =      [text]  # add batch dimension (as the image processor always adds a batch dimension)
													__lowerCamelCase          =      features["""words"""]

										__lowerCamelCase          =      self.tokenizer(
										    text=text if text is not None else features["""words"""]     ,							text_pair=text_pair if text_pair is not None else None     ,							boxes=boxes if boxes is not None else features["""boxes"""]     ,							word_labels=A_     ,							add_special_tokens=A_     ,							padding=A_     ,							truncation=A_     ,							max_length=A_     ,							stride=A_     ,							pad_to_multiple_of=A_     ,							return_token_type_ids=A_     ,							return_attention_mask=A_     ,							return_overflowing_tokens=A_     ,							return_special_tokens_mask=A_     ,							return_offsets_mapping=A_     ,							return_length=A_     ,							verbose=A_     ,							return_tensors=A_     ,							**A_     ,							)

										# add pixel values
										__lowerCamelCase          =      features.pop("""pixel_values"""   )
										if return_overflowing_tokens is True:
													__lowerCamelCase          =      self.get_overflowing_images(A_     ,							encoded_inputs["""overflow_to_sample_mapping"""]   )
										__lowerCamelCase          =      images

										return encoded_inputs




							def   __a   (     self:    Optional[Any]     ,							A_:    Any     ,							A_:    Tuple   ):
										# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
										__lowerCamelCase          =      []
										for sample_idx in overflow_to_sample_mapping:
													images_with_overflow.append(images[sample_idx]   )

										if len(A_   ) != len(A_   ):
													raise ValueError(
													    """Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"""
													    f' {len(A_   )} and {len(A_   )}'   )

										return images_with_overflow




							def   __a   (     self:    Optional[Any]     ,							*A_:    str     ,							**A_:    Dict   ):
										return self.tokenizer.batch_decode(*A_     ,							**A_   )




							def   __a   (     self:    Union[str, Any]     ,							*A_:    Optional[Any]     ,							**A_:    Tuple   ):
										return self.tokenizer.decode(*A_     ,							**A_   )




							@property
							def   __a   (     self:    Union[str, Any]   ):
										return ["input_ids", "bbox", "attention_mask", "image"]




							@property
							def   __a   (     self:    Optional[Any]   ):
										warnings.warn(
										    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""     ,							A_     ,							)
										return self.image_processor_class




							@property
							def   __a   (     self:    List[Any]   ):
										warnings.warn(
										    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""     ,							A_     ,							)
										return self.image_processor




