
import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
					from .testing_utils import (
					    floats_tensor,
					    load_hf_numpy,
					    load_image,
					    load_numpy,
					    load_pt,
					    nightly,
					    parse_flag_from_env,
					    print_tensor_test,
					    require_torch_a,
					    require_torch_gpu,
					    skip_mps,
					    slow,
					    torch_all_close,
					    torch_device,
					)
					from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


_UpperCAmelCase   :					Optional[int]    =			get_logger(__name__)


def  A			(   lowercase					)  ->    Tuple:
		'''simple docstring'''

		if version.parse(lowercase					) < version.parse(lowercase					):
				if "dev" in min_version:
						UpperCamelCase            =	(
						    'This example requires a source install from HuggingFace diffusers (see '
						    '`https://huggingface.co/docs/diffusers/installation#install-from-source`),'
						)
				else:
						UpperCamelCase            =	f'''This example requires a minimum version of {min_version},'''
				error_message += f''' but the version found is {__version__}.\n'''
				raise ImportError(lowercase					)


import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel




def 						A_			(				snake_case				: List[str]			,   snake_case				: int			)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase  	=      pt_attn_layer.in_proj_weight.chunk(3			,   dim=0			)
						__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase  	=      pt_attn_layer.in_proj_bias.chunk(3			,   dim=0			)

						__UpperCamelCase  	=      pt_attn_layer.out_proj.weight
						__UpperCamelCase  	=      pt_attn_layer.out_proj.bias

						__UpperCamelCase  	=      q_proj
						__UpperCamelCase  	=      q_proj_bias

						__UpperCamelCase  	=      k_proj
						__UpperCamelCase  	=      k_proj_bias

						__UpperCamelCase  	=      v_proj
						__UpperCamelCase  	=      v_proj_bias

						__UpperCamelCase  	=      out_proj_weights
						__UpperCamelCase  	=      out_proj_bias




def 						A_			(				snake_case				: Optional[Any]			,   snake_case				: int			)   ->     Any:



						'''simple docstring'''

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




def 						A_			(				snake_case				: Union[str, Any]			,   snake_case				: Optional[Any]			)   ->     Union[str, Any]:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_linear.weight
						__UpperCamelCase  	=      pt_linear.bias




def 						A_			(				snake_case				: Tuple			,   snake_case				: int			)   ->     str:



						'''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_			(				snake_case				: List[Any]			,   snake_case				: Any			)   ->     Optional[int]:



						'''simple docstring'''

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




def 						A_			(				snake_case				: str			,   snake_case				: Dict			)   ->     List[str]:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_model.token_embedding.weight
						__UpperCamelCase  	=      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_			(				snake_case				: str			,   snake_case				: List[str]			)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_model.text_projection.data.T

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




def 						A_			(				snake_case				: List[str]			,   snake_case				: Any			)   ->     str:



						'''simple docstring'''

						__UpperCamelCase  	=      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
						__UpperCamelCase  	=      pt_model.visual.conva.weight.data
						__UpperCamelCase  	=      pt_model.visual.class_embedding
						__UpperCamelCase  	=      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_			(				snake_case				: List[Any]			,   snake_case				: int			,   snake_case				: Any=None			)   ->     List[Any]:



						'''simple docstring'''

						if config_path is not None:
												__UpperCamelCase  	=      CLIPConfig.from_pretrained(snake_case			)
						else:
												__UpperCamelCase  	=      CLIPConfig(projection_dim=512			,   text_config={}			,   vision_config={}			)

						__UpperCamelCase  	=      CLIPModel(snake_case			).eval()

						__UpperCamelCase	,				__UpperCamelCase  	=      load(snake_case			,   device='''cpu'''			,   jit=snake_case			)
						__UpperCamelCase  	=      pt_model.eval()

						copy_text_model_and_projection(snake_case			,   snake_case			)
						copy_vison_model_and_projection(snake_case			,   snake_case			)
						__UpperCamelCase  	=      pt_model.logit_scale

						__UpperCamelCase  	=      torch.arange(0			,   77			).unsqueeze(0			)
						__UpperCamelCase  	=      torch.randn(1			,   3			,   224			,   224			)

						__UpperCamelCase  	=      hf_model(input_ids=snake_case			,   pixel_values=snake_case			,   return_dict=snake_case			)
						__UpperCamelCase  	=      hf_outputs.logits_per_image
						__UpperCamelCase  	=      hf_outputs.logits_per_text
						__UpperCamelCase	,				__UpperCamelCase  	=      pt_model(snake_case			,   snake_case			)

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

						hf_model.save_pretrained(snake_case			)


if __name__ == "__main__":
				lowercase__				:				Union[str, Any]						=      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__				:				str						=      parser.parse_args()

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




