
import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


SCREAMING_SNAKE_CASE__				=							{
    """vit_b32""": {
        """embed_dim""": 512,
        """image_resolution""": 768,
        """context_length""": 16,
        """vocab_size""": 4_9408,
        """vision_layers""": 12,
        """vision_width""": 768,
        """vision_patch_size""": 32,
        """transformer_width""": 512,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_b16""": {
        """embed_dim""": 512,
        """image_resolution""": 768,
        """context_length""": 16,
        """vocab_size""": 4_9408,
        """vision_layers""": 12,
        """vision_width""": 768,
        """vision_patch_size""": 16,
        """transformer_width""": 512,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_l14""": {
        """embed_dim""": 768,
        """image_resolution""": 840,
        """context_length""": 16,
        """vocab_size""": 4_9408,
        """vision_layers""": 24,
        """vision_width""": 1024,
        """vision_patch_size""": 14,
        """transformer_width""": 768,
        """transformer_heads""": 12,
        """transformer_layers""": 12,
    },
}




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: str       ,				SCREAMING_SNAKE_CASE			: Tuple=""       ,				SCREAMING_SNAKE_CASE			: Optional[Any]="/"     )	->		List[Any]:
				__lowercase								=   []

				for k, v in params.items():
								__lowercase								=   parent_key + sep + k if parent_key else k

								if isinstance(SCREAMING_SNAKE_CASE       ,				collections.MutableMapping     ):
												items.extend(flatten_nested_dict(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE       ,				sep=SCREAMING_SNAKE_CASE     ).items()     )
								else:
												items.append((new_key, v)     )
				return dict(SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: List[str]     )	->		List[str]:
				return jax.tree_util.tree_map(lambda SCREAMING_SNAKE_CASE     : x.astype(jnp.floataa     ) if x.dtype == jnp.bfloataa else x       ,				SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: str       ,				SCREAMING_SNAKE_CASE			: str     )	->		Union[str, Any]:
				__lowercase						,   __lowercase						,   __lowercase								=   pt_attn_layer.in_proj_weight.chunk(3       ,				dim=0     )
				__lowercase						,   __lowercase						,   __lowercase								=   pt_attn_layer.in_proj_bias.chunk(3       ,				dim=0     )

				__lowercase								=   pt_attn_layer.out_proj.weight
				__lowercase								=   pt_attn_layer.out_proj.bias

				__lowercase								=   q_proj
				__lowercase								=   q_proj_bias

				__lowercase								=   k_proj
				__lowercase								=   k_proj_bias

				__lowercase								=   v_proj
				__lowercase								=   v_proj_bias

				__lowercase								=   out_proj_weights
				__lowercase								=   out_proj_bias




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Optional[int]       ,				SCREAMING_SNAKE_CASE			: List[Any]     )	->		Optional[int]:
				copy_linear(hf_mlp.fca       ,				pt_mlp.c_fc     )
				copy_linear(hf_mlp.fca       ,				pt_mlp.c_proj     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Optional[Any]       ,				SCREAMING_SNAKE_CASE			: Dict     )	->		List[Any]:
				__lowercase								=   pt_linear.weight
				__lowercase								=   pt_linear.bias




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: List[str]       ,				SCREAMING_SNAKE_CASE			: Optional[Any]     )	->		Tuple:
				# copy layer norms
				copy_linear(hf_layer.layer_norma       ,				pt_layer.ln_a     )
				copy_linear(hf_layer.layer_norma       ,				pt_layer.ln_a     )

				# copy MLP
				copy_mlp(hf_layer.mlp       ,				pt_layer.mlp     )

				# copy attn
				copy_attn_layer(hf_layer.self_attn       ,				pt_layer.attn     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: List[str]       ,				SCREAMING_SNAKE_CASE			: Any     )	->		Optional[int]:
				for hf_layer, pt_layer in zip(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     ):
								copy_layer(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Optional[Any]       ,				SCREAMING_SNAKE_CASE			: Any     )	->		Union[str, Any]:
				# copy  embeds
				__lowercase								=   pt_model.token_embedding.weight
				__lowercase								=   pt_model.positional_embedding

				# copy layer norm
				copy_linear(hf_encoder.final_layer_norm       ,				pt_model.ln_final     )

				# copy hidden layers
				copy_layers(hf_encoder.encoder.layers       ,				pt_model.transformer.resblocks     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Union[str, Any]       ,				SCREAMING_SNAKE_CASE			: Any     )	->		int:
				# copy projection
				__lowercase								=   pt_model.text_projection.data.T

				# copy text encoder
				copy_encoder(hf_model.text_model       ,				SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Union[str, Any]       ,				SCREAMING_SNAKE_CASE			: Any     )	->		List[Any]:
				# copy projection
				__lowercase								=   pt_model.visual.proj.data.T

				# copy layer norms
				copy_linear(hf_model.vision_model.pre_layernorm       ,				pt_model.visual.ln_pre     )
				copy_linear(hf_model.vision_model.post_layernorm       ,				pt_model.visual.ln_post     )

				# copy embeds
				__lowercase								=   pt_model.visual.conva.weight.data
				__lowercase								=   pt_model.visual.class_embedding
				__lowercase								=   pt_model.visual.positional_embedding.data

				# copy encoder
				copy_layers(hf_model.vision_model.encoder.layers       ,				pt_model.visual.transformer.resblocks     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: str       ,				SCREAMING_SNAKE_CASE			: str     )	->		List[Any]:
				__lowercase								=   flatten_nested_dict(flax_params['backbone']['merged_class_token']     )

				__lowercase								=   torch.from_numpy(flax_class_token_params['scale']     )
				__lowercase								=   torch.from_numpy(flax_class_token_params['bias']     )
				__lowercase								=   nn.Parameter(SCREAMING_SNAKE_CASE     )
				__lowercase								=   nn.Parameter(SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: str       ,				SCREAMING_SNAKE_CASE			: str     )	->		Dict:
				__lowercase								=   hf_model.state_dict()
				__lowercase								=   {}

				# Rename class prediction head flax params to pytorch HF
				__lowercase								=   flatten_nested_dict(flax_params['class_head']     )

				for flax_key, v in flax_class_params.items():
								__lowercase								=   flax_key.replace('/'       ,				'.'     )
								__lowercase								=   torch_key.replace('.kernel'       ,				'.weight'     )
								__lowercase								=   torch_key.replace('Dense_0'       ,				'dense0'     )
								__lowercase								=   'class_head.' + torch_key

								if "weight" in torch_key and v.ndim == 2:
												__lowercase								=   v.T

								__lowercase								=   nn.Parameter(torch.from_numpy(SCREAMING_SNAKE_CASE     )     )

				# Rename box prediction box flax params to pytorch HF
				__lowercase								=   flatten_nested_dict(flax_params['obj_box_head']     )

				for flax_key, v in flax_box_params.items():
								__lowercase								=   flax_key.replace('/'       ,				'.'     )
								__lowercase								=   torch_key.replace('.kernel'       ,				'.weight'     )
								__lowercase								=   torch_key.replace('_'       ,				''     ).lower()
								__lowercase								=   'box_head.' + torch_key

								if "weight" in torch_key and v.ndim == 2:
												__lowercase								=   v.T

								__lowercase								=   nn.Parameter(torch.from_numpy(SCREAMING_SNAKE_CASE     )     )

				# Copy flax params to PyTorch params
				for name, param in new_params.items():
								if name in pt_params.keys():
												pt_params[name].copy_(SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Tuple       ,				SCREAMING_SNAKE_CASE			: Tuple     )	->		Any:
				for k, v in flax_attn_params.items():
								if k.startswith('transformer'     ):
												__lowercase								=   k.replace('transformer.resblocks'       ,				'text_model.encoder.layers'     )
								else:
												__lowercase								=   k.replace('visual.transformer.resblocks'       ,				'vision_model.encoder.layers'     )

								__lowercase								=   torch_key.replace('attn'       ,				'self_attn'     )
								__lowercase								=   torch_key.replace('key'       ,				'k_proj'     )
								__lowercase								=   torch_key.replace('value'       ,				'v_proj'     )
								__lowercase								=   torch_key.replace('query'       ,				'q_proj'     )
								__lowercase								=   torch_key.replace('out'       ,				'out_proj'     )

								if "bias" in torch_key and v.ndim == 2:
												__lowercase								=   v.shape[0] * v.shape[1]
												__lowercase								=   v.reshape(SCREAMING_SNAKE_CASE     )

								if "weight" in torch_key and "out" in torch_key:
												__lowercase								=   (v.shape[0] * v.shape[1], v.shape[2])
												__lowercase								=   v.reshape(SCREAMING_SNAKE_CASE     ).T

								if "weight" in torch_key and "out" not in torch_key:
												__lowercase								=   (v.shape[0], v.shape[1] * v.shape[2])
												__lowercase								=   v.reshape(SCREAMING_SNAKE_CASE     ).T

								# Copy flax CLIP attn params to HF PyTorch params
								__lowercase								=   torch.from_numpy(SCREAMING_SNAKE_CASE     )
								hf_backbone.state_dict()[torch_key].copy_(SCREAMING_SNAKE_CASE     )




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Any     )	->		List[Any]:
				__lowercase								=   {}
				__lowercase								=   []

				for k, v in params.items():
								if "attn." in k:
												__lowercase								=   k[: k.rindex('attn.'     ) + 5]
												if base in processed_attn_layers:
																continue

												processed_attn_layers.append(SCREAMING_SNAKE_CASE     )
												__lowercase								=   params[base + 'out.weight'].shape[-1]
												__lowercase								=   params[base + 'out.weight'].reshape(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     ).T
												__lowercase								=   params[base + 'out.bias']
								else:
												__lowercase								=   v
				return new_params




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: List[Any]       ,				SCREAMING_SNAKE_CASE			: Tuple     )	->		Union[str, Any]:
				__lowercase								=   CLIP(**SCREAMING_SNAKE_CASE     )
				torch_model.eval()
				__lowercase								=   torch_model.state_dict()

				__lowercase								=   flatten_nested_dict(flax_params['backbone']['clip']     )
				__lowercase								=   {}

				for flax_key, v in flax_clip_params.items():
								__lowercase								=   flax_key.replace('/'       ,				'.'     )
								__lowercase								=   torch_key.replace('text.token_embedding.embedding'       ,				'token_embedding.kernel'     )

								if (
								    torch_key.startswith('text.transformer'     )
								    or torch_key.startswith('text.text_projection'     )
								    or torch_key.startswith('text.ln_final'     )
								    or torch_key.startswith('text.positional_embedding'     )
								):
												__lowercase								=   torch_key[5:]

								__lowercase								=   torch_key.replace('text_projection.kernel'       ,				'text_projection'     )
								__lowercase								=   torch_key.replace('visual.proj.kernel'       ,				'visual.proj'     )
								__lowercase								=   torch_key.replace('.scale'       ,				'.weight'     )
								__lowercase								=   torch_key.replace('.kernel'       ,				'.weight'     )

								if "conv" in torch_key or "downsample.0.weight" in torch_key:
												__lowercase								=   v.transpose(3       ,				2       ,				0       ,				1     )

								elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
												# Fully connected layers are transposed, embeddings are not
												__lowercase								=   v.T

								__lowercase								=   v

				__lowercase								=   _convert_attn_layers(SCREAMING_SNAKE_CASE     )
				new_torch_params.update(SCREAMING_SNAKE_CASE     )
				__lowercase								=   {}

				# Copy flax CLIP backbone params to PyTorch params
				for name, param in new_torch_params.items():
								if name in torch_clip_params.keys():
												__lowercase								=   torch.from_numpy(new_torch_params[name]     )
												torch_clip_params[name].copy_(SCREAMING_SNAKE_CASE     )
								else:
												__lowercase								=   param

				return torch_clip_params, torch_model, attn_params




@torch.no_grad()
def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Tuple       ,				SCREAMING_SNAKE_CASE			: List[Any]       ,				SCREAMING_SNAKE_CASE			: Union[str, Any]       ,				SCREAMING_SNAKE_CASE			: Dict       ,				SCREAMING_SNAKE_CASE			: Dict=None     )	->		int:
				__lowercase								=   Repository(SCREAMING_SNAKE_CASE       ,				clone_from=F"""google/{pytorch_dump_folder_path}"""     )
				repo.git_pull()

				if config_path is not None:
								__lowercase								=   OwlViTConfig.from_pretrained(SCREAMING_SNAKE_CASE     )
				else:
								__lowercase								=   OwlViTConfig()

				__lowercase								=   OwlViTModel(SCREAMING_SNAKE_CASE     ).eval()
				__lowercase								=   OwlViTForObjectDetection(SCREAMING_SNAKE_CASE     ).eval()

				copy_text_model_and_projection(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )
				copy_vision_model_and_projection(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )
				__lowercase								=   pt_backbone.logit_scale
				copy_flax_attn_params(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )

				__lowercase								=   hf_backbone
				copy_class_merge_token(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )
				copy_class_box_heads(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )

				# Save HF model
				hf_model.save_pretrained(repo.local_dir     )

				# Initialize image processor
				__lowercase								=   OwlViTImageProcessor(
				    size=config.vision_config.image_size       ,				crop_size=config.vision_config.image_size     )
				# Initialize tokenizer
				__lowercase								=   CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32'       ,				pad_token='!'       ,				model_max_length=16     )

				# Initialize processor
				__lowercase								=   OwlViTProcessor(image_processor=SCREAMING_SNAKE_CASE       ,				tokenizer=SCREAMING_SNAKE_CASE     )
				image_processor.save_pretrained(repo.local_dir     )
				processor.save_pretrained(repo.local_dir     )

				repo.git_add()
				repo.git_commit('Upload model and processor'     )
				repo.git_push()


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE__				=							argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--owlvit_version""",
							    default=None,
							    type=str,
							    required=True,
							    help="""OWL-ViT model name [clip_b16, clip_b32, clip_l14].""",
							)
							parser.add_argument(
							    """--owlvit_checkpoint""", default=None, type=str, required=True, help="""Path to flax model checkpoint."""
							)
							parser.add_argument("""--hf_config""", default=None, type=str, required=True, help="""Path to HF model config.""")
							parser.add_argument(
							    """--pytorch_dump_folder_path""", default="""hf_model""", type=str, help="""Path to the output PyTorch model."""
							)
							SCREAMING_SNAKE_CASE__				=							parser.parse_args()

							# Initialize PyToch clip model
							SCREAMING_SNAKE_CASE__				=							args.owlvit_version
							if model_name == "clip_b16":
														SCREAMING_SNAKE_CASE__				=							CONFIGS["""vit_b16"""]
							elif model_name == "clip_b32":
														SCREAMING_SNAKE_CASE__				=							CONFIGS["""vit_b32"""]
							elif model_name == "clip_l14":
														SCREAMING_SNAKE_CASE__				=							CONFIGS["""vit_l14"""]

							# Load from checkpoint and convert params to float-32
							SCREAMING_SNAKE_CASE__				=							checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["""optimizer"""]["""target"""]
							SCREAMING_SNAKE_CASE__				=							jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
							del variables

							# Convert CLIP backbone
							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__				=							convert_clip_backbone(flax_params, torch_config)

							convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)







from ..utils import DummyObject, requires_backends
class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  str	,					*_UpperCAmelCase    :  List[str]	,					**_UpperCAmelCase    :  List[str]							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  str	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  Tuple							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  int							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Dict	,					**_UpperCAmelCase    :  Optional[Any]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Optional[int]							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  List[str]							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  str	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Union[str, Any]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  List[str]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Any							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  List[str]	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  List[str]							)		->						List[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  int	,					**_UpperCAmelCase    :  Optional[Any]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  int							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  List[str]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  str							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  str	,					**_UpperCAmelCase    :  List[Any]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Optional[Any]							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  str	,					**_UpperCAmelCase    :  List[Any]							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  List[Any]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  List[str]							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Any							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Any							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Tuple							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Tuple							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Tuple							)		->						List[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  List[Any]							)		->						List[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  str							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Union[str, Any]							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Dict	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Optional[int]							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Tuple							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  Optional[int]							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Dict	,					**_UpperCAmelCase    :  str							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  List[Any]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Any							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Tuple							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  str	,					**_UpperCAmelCase    :  Any							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Tuple							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  Dict							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  List[str]	,					*_UpperCAmelCase    :  List[str]	,					**_UpperCAmelCase    :  List[str]							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  List[Any]							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  str							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  str	,					**_UpperCAmelCase    :  Optional[int]							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Optional[Any]							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Dict							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  List[str]	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  str							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  List[str]							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  int	,					**_UpperCAmelCase    :  Optional[int]							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  List[str]	,					**_UpperCAmelCase    :  List[Any]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Tuple							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Any	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Any							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Any							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Any							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  List[Any]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Dict							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Optional[int]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  List[str]	,					**_UpperCAmelCase    :  Optional[int]							)		->						List[str]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  List[str]	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  str							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  str							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)





