





"""simple docstring"""






import argparse
import json

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

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE				)		->							Tuple:






       """simple docstring"""




       _UpperCAmelCase			     =  TimesformerConfig()

       if "large" in model_name:
              _UpperCAmelCase			     =  96

       if "hr" in model_name:
              _UpperCAmelCase			     =  16
              _UpperCAmelCase			     =  448

       _UpperCAmelCase			     =  """huggingface/label-files"""
       if "k400" in model_name:
              _UpperCAmelCase			     =  400
              _UpperCAmelCase			     =  """kinetics400-id2label.json"""
       elif "k600" in model_name:
              _UpperCAmelCase			     =  600
              _UpperCAmelCase			     =  """kinetics600-id2label.json"""
       elif "ssv2" in model_name:
              _UpperCAmelCase			     =  174
              _UpperCAmelCase			     =  """something-something-v2-id2label.json"""
       else:
              raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'				)
       _UpperCAmelCase			     =  json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,repo_type='dataset'				),'r'				)				)
       _UpperCAmelCase			     =  {int(SCREAMING_SNAKE_CASE				): v for k, v in idalabel.items()}
       _UpperCAmelCase			     =  idalabel
       _UpperCAmelCase			     =  {v: k for k, v in idalabel.items()}

       return config

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE				)		->							Union[str, Any]:






       """simple docstring"""




       if "encoder." in name:
              _UpperCAmelCase			     =  name.replace('encoder.',''				)
       if "cls_token" in name:
              _UpperCAmelCase			     =  name.replace('cls_token','timesformer.embeddings.cls_token'				)
       if "pos_embed" in name:
              _UpperCAmelCase			     =  name.replace('pos_embed','timesformer.embeddings.position_embeddings'				)
       if "time_embed" in name:
              _UpperCAmelCase			     =  name.replace('time_embed','timesformer.embeddings.time_embeddings'				)
       if "patch_embed.proj" in name:
              _UpperCAmelCase			     =  name.replace('patch_embed.proj','timesformer.embeddings.patch_embeddings.projection'				)
       if "patch_embed.norm" in name:
              _UpperCAmelCase			     =  name.replace('patch_embed.norm','timesformer.embeddings.norm'				)
       if "blocks" in name:
              _UpperCAmelCase			     =  name.replace('blocks','timesformer.encoder.layer'				)
       if "attn.proj" in name:
              _UpperCAmelCase			     =  name.replace('attn.proj','attention.output.dense'				)
       if "attn" in name and "bias" not in name and "temporal" not in name:
              _UpperCAmelCase			     =  name.replace('attn','attention.self'				)
       if "attn" in name and "temporal" not in name:
              _UpperCAmelCase			     =  name.replace('attn','attention.attention'				)
       if "temporal_norm1" in name:
              _UpperCAmelCase			     =  name.replace('temporal_norm1','temporal_layernorm'				)
       if "temporal_attn.proj" in name:
              _UpperCAmelCase			     =  name.replace('temporal_attn','temporal_attention.output.dense'				)
       if "temporal_fc" in name:
              _UpperCAmelCase			     =  name.replace('temporal_fc','temporal_dense'				)
       if "norm1" in name and "temporal" not in name:
              _UpperCAmelCase			     =  name.replace('norm1','layernorm_before'				)
       if "norm2" in name:
              _UpperCAmelCase			     =  name.replace('norm2','layernorm_after'				)
       if "mlp.fc1" in name:
              _UpperCAmelCase			     =  name.replace('mlp.fc1','intermediate.dense'				)
       if "mlp.fc2" in name:
              _UpperCAmelCase			     =  name.replace('mlp.fc2','output.dense'				)
       if "norm.weight" in name and "fc" not in name and "temporal" not in name:
              _UpperCAmelCase			     =  name.replace('norm.weight','timesformer.layernorm.weight'				)
       if "norm.bias" in name and "fc" not in name and "temporal" not in name:
              _UpperCAmelCase			     =  name.replace('norm.bias','timesformer.layernorm.bias'				)
       if "head" in name:
              _UpperCAmelCase			     =  name.replace('head','classifier'				)

       return name

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				)		->							Dict:






       """simple docstring"""




       for key in orig_state_dict.copy().keys():
              _UpperCAmelCase			     =  orig_state_dict.pop(SCREAMING_SNAKE_CASE				)

              if key.startswith('model.'				):
                     _UpperCAmelCase			     =  key.replace('model.',''				)

              if "qkv" in key:
                     _UpperCAmelCase			     =  key.split('.'				)
                     _UpperCAmelCase			     =  int(key_split[1]				)
                     _UpperCAmelCase			     =  """timesformer.encoder.layer."""
                     if "temporal" in key:
                            _UpperCAmelCase			     =  """.temporal_attention.attention.qkv."""
                     else:
                            _UpperCAmelCase			     =  """.attention.attention.qkv."""
                     if "weight" in key:
                            _UpperCAmelCase			     =  val
                     else:
                            _UpperCAmelCase			     =  val
              else:
                     _UpperCAmelCase			     =  val

       return orig_state_dict

def    __lowerCamelCase     (							)		->							Tuple:






       """simple docstring"""




       _UpperCAmelCase			     =  hf_hub_download(
           repo_id='hf-internal-testing/spaghetti-video',filename='eating_spaghetti.npy',repo_type='dataset'				)
       _UpperCAmelCase			     =  np.load(SCREAMING_SNAKE_CASE				)
       return list(SCREAMING_SNAKE_CASE				)

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				)		->							Union[str, Any]:






       """simple docstring"""




       _UpperCAmelCase			     =  get_timesformer_config(SCREAMING_SNAKE_CASE				)

       _UpperCAmelCase			     =  TimesformerForVideoClassification(SCREAMING_SNAKE_CASE				)

       # download original checkpoint, hosted on Google Drive
       _UpperCAmelCase			     =  """pytorch_model.bin"""
       gdown.cached_download(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,quiet=SCREAMING_SNAKE_CASE				)
       _UpperCAmelCase			     =  torch.load(SCREAMING_SNAKE_CASE,map_location='cpu'				)
       if "model" in files:
              _UpperCAmelCase			     =  files["""model"""]
       elif "module" in files:
              _UpperCAmelCase			     =  files["""module"""]
       else:
              _UpperCAmelCase			     =  files["""model_state"""]
       _UpperCAmelCase			     =  convert_state_dict(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				)

       model.load_state_dict(SCREAMING_SNAKE_CASE				)
       model.eval()

       # verify model on basic input
       _UpperCAmelCase			     =  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5],image_std=[0.5, 0.5, 0.5]				)
       _UpperCAmelCase			     =  prepare_video()
       _UpperCAmelCase			     =  image_processor(video[:8],return_tensors='pt'				)

       _UpperCAmelCase			     =  model(**SCREAMING_SNAKE_CASE				)
       _UpperCAmelCase			     =  outputs.logits

       _UpperCAmelCase			     =  [
           # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-k400""",
           """timesformer-large-finetuned-k400""",
           """timesformer-hr-finetuned-k400""",
           # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-k600""",
           """timesformer-large-finetuned-k600""",
           """timesformer-hr-finetuned-k600""",
           # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
           """timesformer-base-finetuned-ssv2""",
           """timesformer-large-finetuned-ssv2""",
           """timesformer-hr-finetuned-ssv2""",
       ]

       # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
       if model_name == "timesformer-base-finetuned-k400":
              _UpperCAmelCase			     =  torch.Size([1, 400]				)
              _UpperCAmelCase			     =  torch.tensor([-0.3_016, -0.7_713, -0.4_205]				)
       elif model_name == "timesformer-base-finetuned-k600":
              _UpperCAmelCase			     =  torch.Size([1, 600]				)
              _UpperCAmelCase			     =  torch.tensor([-0.7_267, -0.7_466, 3.2_404]				)
       elif model_name == "timesformer-base-finetuned-ssv2":
              _UpperCAmelCase			     =  torch.Size([1, 174]				)
              _UpperCAmelCase			     =  torch.tensor([-0.9_059, 0.6_433, -3.1_457]				)
       elif model_name == "timesformer-large-finetuned-k400":
              _UpperCAmelCase			     =  torch.Size([1, 400]				)
              _UpperCAmelCase			     =  torch.tensor([0, 0, 0]				)
       elif model_name == "timesformer-large-finetuned-k600":
              _UpperCAmelCase			     =  torch.Size([1, 600]				)
              _UpperCAmelCase			     =  torch.tensor([0, 0, 0]				)
       elif model_name == "timesformer-large-finetuned-ssv2":
              _UpperCAmelCase			     =  torch.Size([1, 174]				)
              _UpperCAmelCase			     =  torch.tensor([0, 0, 0]				)
       elif model_name == "timesformer-hr-finetuned-k400":
              _UpperCAmelCase			     =  torch.Size([1, 400]				)
              _UpperCAmelCase			     =  torch.tensor([-0.9_617, -3.7_311, -3.7_708]				)
       elif model_name == "timesformer-hr-finetuned-k600":
              _UpperCAmelCase			     =  torch.Size([1, 600]				)
              _UpperCAmelCase			     =  torch.tensor([2.5_273, 0.7_127, 1.8_848]				)
       elif model_name == "timesformer-hr-finetuned-ssv2":
              _UpperCAmelCase			     =  torch.Size([1, 174]				)
              _UpperCAmelCase			     =  torch.tensor([-3.6_756, -0.7_513, 0.7_180]				)
       else:
              raise ValueError(F"""Model name not supported. Should be one of {model_names}"""				)

       # verify logits
       assert logits.shape == expected_shape
       assert torch.allclose(logits[0, :3],SCREAMING_SNAKE_CASE,atol=1E-4				)
       print('Logits ok!'				)

       if pytorch_dump_folder_path is not None:
              print(F"""Saving model and image processor to {pytorch_dump_folder_path}"""				)
              image_processor.save_pretrained(SCREAMING_SNAKE_CASE				)
              model.save_pretrained(SCREAMING_SNAKE_CASE				)

       if push_to_hub:
              print('Pushing to the hub...'				)
              model.push_to_hub(F"""fcakyon/{model_name}"""				)


if __name__ == "__main__":
    lowerCAmelCase_      =				argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '''--checkpoint_url''',
        default='''https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download''',
        type=str,
        help=(
            '''URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'''
            ''' download link.'''
        ),
    )
    parser.add_argument(
        '''--pytorch_dump_folder_path''',
        default='''''',
        type=str,
        help='''Path to the output PyTorch model directory.''',
    )
    parser.add_argument('''--model_name''', default='''timesformer-base-finetuned-k400''', type=str, help='''Name of the model.''')
    parser.add_argument(
        '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
    )

    lowerCAmelCase_      =				parser.parse_args()
    convert_timesformer_checkpoint(
        args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
    )










'''simple docstring'''
from ..utils import DummyObject, requires_backends







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					str						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Dict						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Dict						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					int						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Tuple						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Union[str, Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Tuple						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					str						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Union[str, Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Optional[Any]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					int						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Any						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Dict						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Optional[int]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Optional[int]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Dict						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[int]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)




