


"""simple docstring"""






import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel



def 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      Optional[int]	)							->	Optional[Any]:

	'''simple docstring'''


	snake_case__,					snake_case__,					snake_case__  :						Tuple		=      pt_attn_layer.in_proj_weight.chunk(3				,    dim=0	)
	snake_case__,					snake_case__,					snake_case__  :						Any		=      pt_attn_layer.in_proj_bias.chunk(3				,    dim=0	)

	snake_case__  :						List[str]		=      pt_attn_layer.out_proj.weight
	snake_case__  :						Optional[int]		=      pt_attn_layer.out_proj.bias

	snake_case__  :						Optional[Any]		=      q_proj
	snake_case__  :						Optional[int]		=      q_proj_bias

	snake_case__  :						Tuple		=      k_proj
	snake_case__  :						List[str]		=      k_proj_bias

	snake_case__  :						Dict		=      v_proj
	snake_case__  :						Optional[int]		=      v_proj_bias

	snake_case__  :						List[Any]		=      out_proj_weights
	snake_case__  :						Dict		=      out_proj_bias



def 			A__		(					_UpperCAmelCase    :      Tuple				,    _UpperCAmelCase    :      List[Any]	)							->	Tuple:

	'''simple docstring'''


	copy_linear(hf_mlp.fca				,    pt_mlp.c_fc	)
	copy_linear(hf_mlp.fca				,    pt_mlp.c_proj	)



def 			A__		(					_UpperCAmelCase    :      Union[str, Any]				,    _UpperCAmelCase    :      Optional[Any]	)							->	Union[str, Any]:

	'''simple docstring'''


	snake_case__  :						Optional[int]		=      pt_linear.weight
	snake_case__  :						str		=      pt_linear.bias



def 			A__		(					_UpperCAmelCase    :      Optional[int]				,    _UpperCAmelCase    :      Optional[Any]	)							->	List[Any]:

	'''simple docstring'''


	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 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      str	)							->	str:

	'''simple docstring'''


	for hf_layer, pt_layer in zip(_UpperCAmelCase				,    _UpperCAmelCase	):
		copy_layer(_UpperCAmelCase				,    _UpperCAmelCase	)



def 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      Optional[Any]	)							->	Tuple:

	'''simple docstring'''


	snake_case__  :						Tuple		=      pt_model.token_embedding.weight
	snake_case__  :						Dict		=      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 			A__		(					_UpperCAmelCase    :      List[str]				,    _UpperCAmelCase    :      Any	)							->	List[Any]:

	'''simple docstring'''


	snake_case__  :						Dict		=      pt_model.text_projection.data.T

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



def 			A__		(					_UpperCAmelCase    :      Dict				,    _UpperCAmelCase    :      Optional[int]	)							->	Tuple:

	'''simple docstring'''


	snake_case__  :						Tuple		=      pt_model.visual.proj.data.T

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

	# copy embeds
	snake_case__  :						Optional[Any]		=      pt_model.visual.conva.weight.data
	snake_case__  :						str		=      pt_model.visual.class_embedding
	snake_case__  :						int		=      pt_model.visual.positional_embedding.data

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



@torch.no_grad()
def 			A__		(					_UpperCAmelCase    :      str				,    _UpperCAmelCase    :      Dict				,    _UpperCAmelCase    :      Union[str, Any]=None	)							->	Union[str, Any]:

	'''simple docstring'''


	if config_path is not None:
		snake_case__  :						List[str]		=      CLIPConfig.from_pretrained(_UpperCAmelCase	)
	else:
		snake_case__  :						List[str]		=      CLIPConfig(projection_dim=5_12				,    text_config={}				,    vision_config={}	)

	snake_case__  :						Dict		=      CLIPModel(_UpperCAmelCase	).eval()

	snake_case__,					snake_case__  :						Any		=      load(_UpperCAmelCase				,    device="cpu"				,    jit=_UpperCAmelCase	)
	snake_case__  :						int		=      pt_model.eval()

	copy_text_model_and_projection(_UpperCAmelCase				,    _UpperCAmelCase	)
	copy_vison_model_and_projection(_UpperCAmelCase				,    _UpperCAmelCase	)
	snake_case__  :						Optional[int]		=      pt_model.logit_scale

	snake_case__  :						List[str]		=      torch.arange(0				,    77	).unsqueeze(0	)
	snake_case__  :						str		=      torch.randn(1				,    3				,    2_24				,    2_24	)

	snake_case__  :						List[Any]		=      hf_model(input_ids=_UpperCAmelCase				,    pixel_values=_UpperCAmelCase				,    return_dict=_UpperCAmelCase	)
	snake_case__  :						Optional[int]		=      hf_outputs.logits_per_image
	snake_case__  :						Dict		=      hf_outputs.logits_per_text
	snake_case__,					snake_case__  :						Tuple		=      pt_model(_UpperCAmelCase				,    _UpperCAmelCase	)

	assert torch.allclose(_UpperCAmelCase				,    _UpperCAmelCase				,    atol=1e-3	)
	assert torch.allclose(_UpperCAmelCase				,    _UpperCAmelCase				,    atol=1e-3	)

	hf_model.save_pretrained(_UpperCAmelCase	)


if __name__ == "__main__":
					lowercase  		=			argparse.ArgumentParser()
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
					parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
					lowercase  		=			parser.parse_args()

					convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)









"""simple docstring"""







from __future__ import annotations

import random
import string






class  __A							:






 """simple docstring"""




 def __init__(						self					,       __A = None		)   ->	None:
     a											=passcode or self.__passcode_creator()
     a											=self.__make_key_list()
     a											=self.__make_shift_key()


 def __str__(						self		)   ->	str:
     return "".join(self.__passcode		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A		)   ->	list[int]:
     for i in range(1					,       len(__A		)					,       2		):
         iterlist[i] *= -1
     return iterlist


 def  SCREAMING_SNAKE_CASE				(						self		)   ->	list[str]:
     a											=string.ascii_letters + string.digits
     a											=[random.choice(__A		) for _ in range(random.randint(10					,       20		)		)]
     return password


 def  SCREAMING_SNAKE_CASE				(						self		)   ->	list[str]:
     a											=(
         string.ascii_letters + string.digits + string.punctuation + ''' \t\n'''
     )

     a											=[]

     # creates points known as breakpoints to break the key_list_options at those
     # points and pivot each substring
     a											=sorted(set(self.__passcode		)		)
     a											=[]

     # algorithm for creating a new shuffled list, keys_l, out of key_list_options
     for i in key_list_options:
         temp_list.extend(__A		)

         # checking breakpoints at which to pivot temporary sublist and add it into
         # keys_l
         if i in breakpoints or i == key_list_options[-1]:
             keys_l.extend(temp_list[::-1]		)
             temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
     return keys_l


 def  SCREAMING_SNAKE_CASE				(						self		)   ->	int:
     a											=sum(self.__neg_pos([ord(__A		) for x in self.__passcode]		)		)
     return num if num > 0 else len(self.__passcode		)


 def  SCREAMING_SNAKE_CASE				(						self					,       __A		)   ->	str:
     a											=''''''

     # decoding shift like Caesar cipher algorithm implementing negative shift or
     # reverse shift or left shift
     for i in encoded_message:
         a											=self.__key_list.index(__A		)
         decoded_message += self.__key_list[
             (position - self.__shift_key) % -len(self.__key_list		)
         ]

     return decoded_message





 def  SCREAMING_SNAKE_CASE				(						self					,       __A		)   ->	str:
     a											=''''''

     # encoding shift like Caesar cipher algorithm implementing positive shift or
     # forward shift or right shift
     for i in plaintext:
         a											=self.__key_list.index(__A		)
         encoded_message += self.__key_list[
             (position + self.__shift_key) % len(self.__key_list		)
         ]

     return encoded_message

def _A		(		lowercase = "Hello, this is a modified Caesar cipher"						):







    """simple docstring"""
    a											=ShuffledShiftCipher()
    return cipa.decrypt(cipa.encrypt(lowercase						)						)


if __name__ == "__main__":
       import doctest

       doctest.testmod()