


'''simple docstring'''
import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


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

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
__SCREAMING_SNAKE_CASE				:							List[Any]		       =		direct_transformers_import(Path(__file__).parent)


__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		{
    '''AutoTokenizer''': '''PreTrainedTokenizerBase''',
    '''AutoFeatureExtractor''': '''FeatureExtractionMixin''',
    '''AutoImageProcessor''': '''ImageProcessingMixin''',
}






class 				__lowerCAmelCase      (      __UpperCAmelCase	):

						"""simple docstring"""






						_UpperCAmelCase		:					Optional[int]      	=["""feature_extractor""", """tokenizer"""]
						# Names need to be attr_class for attr in attributes
						_UpperCAmelCase		:					Optional[Any]      	=None
						_UpperCAmelCase		:					str      	=None
						_UpperCAmelCase		:					Dict      	=None






						def __init__(     self       :			List[Any]   ,     *lowerCAmelCase       :			int   ,     **lowerCAmelCase       :			Dict  ):



													for key in kwargs:
																				if key not in self.attributes:
																											raise TypeError(F"Unexpected keyword argument {key}."  )
													for arg, attribute_name in zip(lowerCamelCase__   ,     self.attributes  ):
																				if attribute_name in kwargs:
																											raise TypeError(F"Got multiple values for argument {attribute_name}."  )
																				else:
																											A_ 						=		arg

													if len(lowerCamelCase__  ) != len(self.attributes  ):
																				raise ValueError(
																				    F"This processor requires {len(self.attributes  )} arguments: {', '.join(self.attributes  )}. Got "
																				    F"{len(lowerCamelCase__  )} arguments instead."  )

													# Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
													for attribute_name, arg in kwargs.items():
																				A_ 						=		getattr(self   ,     F"{attribute_name}_class"  )
																				# Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
																				A_ 						=		AUTO_TO_BASE_CLASS_MAPPING.get(lowerCamelCase__   ,     lowerCamelCase__  )
																				if isinstance(lowerCamelCase__   ,     lowerCamelCase__  ):
																											A_ 						=		tuple(getattr(lowerCamelCase__   ,     lowerCamelCase__  ) for n in class_name if n is not None  )
																				else:
																											A_ 						=		getattr(lowerCamelCase__   ,     lowerCamelCase__  )

																				if not isinstance(lowerCamelCase__   ,     lowerCamelCase__  ):
																											raise ValueError(
																											    F"Received a {type(lowerCamelCase__  ).__name__} for argument {attribute_name}, but a {class_name} was expected."  )

																				setattr(self   ,     lowerCamelCase__   ,     lowerCamelCase__  )






						def __repr__(     self       :			Union[str, Any]  ):
													A_ 						=		[F"- {name}: {repr(getattr(self   ,     lowerCamelCase__  )  )}" for name in self.attributes]
													A_ 						=		"\n".join(lowerCamelCase__  )
													return F"{self.__class__.__name__}:\n{attributes_repr}"






						def 							_UpperCAmelCase					(     self       :			Tuple   ,     lowerCAmelCase       :			Optional[int]   ,     lowerCAmelCase       :			Optional[int] = False   ,     **lowerCAmelCase       :			Optional[int]  ):
													os.makedirs(lowerCamelCase__   ,     exist_ok=lowerCamelCase__  )

													if push_to_hub:
																				A_ 						=		kwargs.pop("commit_message"   ,     lowerCamelCase__  )
																				A_ 						=		kwargs.pop("repo_id"   ,     save_directory.split(os.path.sep  )[-1]  )
																				A_ 						=		self._create_repo(lowerCamelCase__   ,     **lowerCamelCase__  )
																				A_ 						=		self._get_files_timestamps(lowerCamelCase__  )
													# If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
													# loaded from the Hub.
													if self._auto_class is not None:
																				A_ 						=		[getattr(self   ,     lowerCamelCase__  ) for attribute_name in self.attributes]
																				A_ 						=		[(a.init_kwargs if isinstance(lowerCamelCase__   ,     lowerCamelCase__  ) else a) for a in attrs]
																				custom_object_save(self   ,     lowerCamelCase__   ,     config=lowerCamelCase__  )

													for attribute_name in self.attributes:
																				A_ 						=		getattr(self   ,     lowerCamelCase__  )
																				# Include the processor class in the attribute config so this processor can then be reloaded with the
																				# `AutoProcessor` API.
																				if hasattr(lowerCamelCase__   ,     "_set_processor_class"  ):
																											attribute._set_processor_class(self.__class__.__name__  )
																				attribute.save_pretrained(lowerCamelCase__  )

													if self._auto_class is not None:
																				# We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
																				for attribute_name in self.attributes:
																											A_ 						=		getattr(self   ,     lowerCamelCase__  )
																											if isinstance(lowerCamelCase__   ,     lowerCamelCase__  ):
																																		del attribute.init_kwargs["auto_map"]

													if push_to_hub:
																				self._upload_modified_files(
																				    lowerCamelCase__   ,     lowerCamelCase__   ,     lowerCamelCase__   ,     commit_message=lowerCamelCase__   ,     token=kwargs.get("use_auth_token"  )   ,     )






						@classmethod
						def 							_UpperCAmelCase					(     cls       :			List[Any]   ,     lowerCAmelCase       :			int   ,     lowerCAmelCase       :			Optional[int] = None   ,     lowerCAmelCase       :			int = False   ,     lowerCAmelCase       :			Any = False   ,     lowerCAmelCase       :			Dict = None   ,     lowerCAmelCase       :			Tuple = "main"   ,     **lowerCAmelCase       :			Optional[int]   ,     ):
													A_ 						=		cache_dir
													A_ 						=		force_download
													A_ 						=		local_files_only
													A_ 						=		revision

													A_ 						=		kwargs.pop("use_auth_token"   ,     lowerCamelCase__  )
													if use_auth_token is not None:
																				warnings.warn(
																				    "The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers."   ,     lowerCamelCase__  )
																				if token is not None:
																											raise ValueError(
																											    "`token` and `use_auth_token` are both specified. Please set only the argument `token`."  )
																				A_ 						=		use_auth_token

													if token is not None:
																				# change to `token` in a follow-up PR
																				A_ 						=		token

													A_ 						=		cls._get_arguments_from_pretrained(lowerCamelCase__   ,     **lowerCamelCase__  )
													return cls(*lowerCamelCase__  )






						@classmethod
						def 							_UpperCAmelCase					(     cls       :			Dict   ,     lowerCAmelCase       :			str="AutoProcessor"  ):



													if not isinstance(lowerCamelCase__   ,     lowerCamelCase__  ):
																				A_ 						=		auto_class.__name__

													import transformers.models.auto as auto_module

													if not hasattr(lowerCamelCase__   ,     lowerCamelCase__  ):
																				raise ValueError(F"{auto_class} is not a valid auto class."  )

													A_ 						=		auto_class






						@classmethod
						def 							_UpperCAmelCase					(     cls       :			str   ,     lowerCAmelCase       :			Any   ,     **lowerCAmelCase       :			Dict  ):
													A_ 						=		[]
													for attribute_name in cls.attributes:
																				A_ 						=		getattr(cls   ,     F"{attribute_name}_class"  )
																				if isinstance(lowerCamelCase__   ,     lowerCamelCase__  ):
																											A_ 						=		tuple(getattr(lowerCamelCase__   ,     lowerCamelCase__  ) if n is not None else None for n in class_name  )
																											A_ 						=		kwargs.get("use_fast"   ,     lowerCamelCase__  )
																											if use_fast and classes[1] is not None:
																																		A_ 						=		classes[1]
																											else:
																																		A_ 						=		classes[0]
																				else:
																											A_ 						=		getattr(lowerCamelCase__   ,     lowerCamelCase__  )

																				args.append(attribute_class.from_pretrained(lowerCamelCase__   ,     **lowerCamelCase__  )  )
													return args






						@property
						def 							_UpperCAmelCase					(     self       :			Tuple  ):
													A_ 						=		getattr(self   ,     self.attributes[0]  )
													return getattr(lowerCamelCase__   ,     "model_input_names"   ,     lowerCamelCase__  )



__SCREAMING_SNAKE_CASE				:							List[Any]		       =		copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
							__SCREAMING_SNAKE_CASE				:							str		       =		ProcessorMixin.push_to_hub.__doc__.format(
							    object='''processor''', object_class='''AutoProcessor''', object_files='''processor files'''
							)









'''simple docstring'''
import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		"https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"

							with open(UpperCamelCase_	,     "wb"   ) as f:
														with requests.get(UpperCamelCase_	,     stream=UpperCamelCase_   ) as req:
																					for chunk in req.iter_content(chunk_size=2_0_4_8   ):
																												f.write(UpperCamelCase_   )







def 			a_							(  ):
							A_ 						=		VivitConfig()

							A_ 						=		4_0_0
							A_ 						=		"huggingface/label-files"
							A_ 						=		"kinetics400-id2label.json"

							A_ 						=		json.load(open(hf_hub_download(UpperCamelCase_	,     UpperCamelCase_	,     repo_type="dataset"   )	,     "r"   )   )
							A_ 						=		{int(UpperCamelCase_   ): v for k, v in idalabel.items()}
							A_ 						=		idalabel
							A_ 						=		{v: k for k, v in idalabel.items()}
							return config







def 			a_							(  ):
							A_ 						=		hf_hub_download(
							    repo_id="hf-internal-testing/spaghetti-video"	,     filename="eating_spaghetti_32_frames.npy"	,     repo_type="dataset"   )
							A_ 						=		np.load(UpperCamelCase_   )
							return list(UpperCamelCase_   )







def 			a_							(  UpperCamelCase_   ):
							if np.ndim(UpperCamelCase_   ) == 2:
														return transform_attention_bias(UpperCamelCase_   )

							elif np.ndim(UpperCamelCase_   ) == 3:
														return transform_attention_kernel(UpperCamelCase_   )

							else:
														raise Exception(f"Invalid number of dimesions: {np.ndim(UpperCamelCase_   )}"   )







def 			a_							(  UpperCamelCase_   ):
							return current.flatten()







def 			a_							(  UpperCamelCase_   ):
							return np.reshape(UpperCamelCase_	,     (current.shape[0], current.shape[1] * current.shape[2])   ).T







def 			a_							(  UpperCamelCase_   ):
							return np.reshape(UpperCamelCase_	,     (current.shape[0] * current.shape[1], current.shape[2])   ).T







def 			a_							(  UpperCamelCase_	,     UpperCamelCase_   ):
							A_ 						=		state_dict["optimizer"]["target"]["Transformer"][f"encoderblock_{i}"]

							A_ 						=		f"encoder.layer.{i}."
							A_ 						=		{
							    prefix + "intermediate.dense.bias": state["MlpBlock_0"]["Dense_0"]["bias"],
							    prefix + "intermediate.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_0"]["kernel"]   ),
							    prefix + "output.dense.bias": state["MlpBlock_0"]["Dense_1"]["bias"],
							    prefix + "output.dense.weight": np.transpose(state["MlpBlock_0"]["Dense_1"]["kernel"]   ),
							    prefix + "layernorm_before.bias": state["LayerNorm_0"]["bias"],
							    prefix + "layernorm_before.weight": state["LayerNorm_0"]["scale"],
							    prefix + "layernorm_after.bias": state["LayerNorm_1"]["bias"],
							    prefix + "layernorm_after.weight": state["LayerNorm_1"]["scale"],
							    prefix
							    + "attention.attention.query.bias": transform_attention(
							        state["MultiHeadDotProductAttention_0"]["query"]["bias"]   ),
							    prefix
							    + "attention.attention.query.weight": transform_attention(
							        state["MultiHeadDotProductAttention_0"]["query"]["kernel"]   ),
							    prefix
							    + "attention.attention.key.bias": transform_attention(state["MultiHeadDotProductAttention_0"]["key"]["bias"]   ),
							    prefix
							    + "attention.attention.key.weight": transform_attention(
							        state["MultiHeadDotProductAttention_0"]["key"]["kernel"]   ),
							    prefix
							    + "attention.attention.value.bias": transform_attention(
							        state["MultiHeadDotProductAttention_0"]["value"]["bias"]   ),
							    prefix
							    + "attention.attention.value.weight": transform_attention(
							        state["MultiHeadDotProductAttention_0"]["value"]["kernel"]   ),
							    prefix + "attention.output.dense.bias": state["MultiHeadDotProductAttention_0"]["out"]["bias"],
							    prefix
							    + "attention.output.dense.weight": transform_attention_output_weight(
							        state["MultiHeadDotProductAttention_0"]["out"]["kernel"]   ),
							}

							return new_state







def 			a_							(  UpperCamelCase_   ):
							return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()]   )







def 			a_							(  UpperCamelCase_	,     UpperCamelCase_=False   ):
							A_ 						=		get_n_layers(UpperCamelCase_   )

							A_ 						=		OrderedDict()

							A_ 						=		state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
							A_ 						=		state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]

							A_ 						=		np.transpose(
							    state_dict["optimizer"]["target"]["embedding"]["kernel"]	,     (4, 3, 0, 1, 2)   )
							A_ 						=		state_dict["optimizer"]["target"]["embedding"]["bias"]

							A_ 						=		state_dict["optimizer"]["target"]["cls"]
							A_ 						=		state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
							    "pos_embedding"
							]

							for i in range(UpperCamelCase_   ):
														new_state.update(transform_state_encoder_block(UpperCamelCase_	,     UpperCamelCase_   )   )

							if classification_head:
														A_ 						=		{"vivit." + k: v for k, v in new_state.items()}
														A_ 						=		np.transpose(state_dict["optimizer"]["target"]["output_projection"]["kernel"]   )
														A_ 						=		np.transpose(state_dict["optimizer"]["target"]["output_projection"]["bias"]   )

							return {k: torch.tensor(UpperCamelCase_   ) for k, v in new_state.items()}







def 			a_							(  ):
							A_ 						=		VivitImageProcessor()

							assert extractor.do_resize is True
							assert extractor.size == {"shortest_edge": 2_5_6}
							assert extractor.do_center_crop is True
							assert extractor.crop_size == {"width": 2_2_4, "height": 2_2_4}
							assert extractor.resample == PILImageResampling.BILINEAR

							# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
							# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
							# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
							assert extractor.do_normalize is False
							assert extractor.do_rescale is True
							assert extractor.rescale_factor == 1 / 2_5_5

							# zero-centering = True in original implementation
							assert extractor.do_zero_centering is True

							return extractor







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		"checkpoint"

							if not os.path.exists(UpperCamelCase_   ):
														download_checkpoint(UpperCamelCase_   )

							A_ 						=		restore_checkpoint(UpperCamelCase_	,     UpperCamelCase_   )
							A_ 						=		transform_state(UpperCamelCase_	,     classification_head=UpperCamelCase_   )

							A_ 						=		get_vivit_config()

							assert config.image_size == 2_2_4
							assert config.num_frames == 3_2

							A_ 						=		VivitForVideoClassification(UpperCamelCase_   )
							model.load_state_dict(UpperCamelCase_   )
							model.eval()

							A_ 						=		get_processor()

							A_ 						=		prepare_video()
							A_ 						=		extractor(UpperCamelCase_	,     return_tensors="pt"   )

							A_ 						=		model(**UpperCamelCase_   )

							A_ 						=		torch.Size([1, 4_0_0]   )
							A_ 						=		torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]   )

							assert outputs.logits.shape == expected_shape
							assert torch.allclose(outputs.logits[0, :5]	,     UpperCamelCase_	,     atol=1e-4   ), outputs.logits[0, :5]

							model.save_pretrained(UpperCamelCase_   )
							extractor.save_pretrained(UpperCamelCase_   )


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE				:							Optional[Any]		       =		argparse.ArgumentParser()

							parser.add_argument('''--output_model_name''', '''-o''', type=str, help='''Output path for the converted HuggingFace model''')

							__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		parser.parse_args()
							convert(args.output_model_name)





