


"""simple docstring"""







import argparse

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

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    XCLIPTextConfig()

					# derive patch size from model name
					__SCREAMING_SNAKE_CASE						       =    model_name.find("patch"       )
					__SCREAMING_SNAKE_CASE						       =    int(model_name[start_idx + len("patch"       ) : start_idx + len("patch"       ) + 2]       )
					__SCREAMING_SNAKE_CASE						       =    XCLIPVisionConfig(patch_size=lowerCAmelCase_  ,						num_frames=lowerCAmelCase_       )

					if "large" in model_name:
										__SCREAMING_SNAKE_CASE						       =    768
										__SCREAMING_SNAKE_CASE						       =    3072
										__SCREAMING_SNAKE_CASE						       =    12

										__SCREAMING_SNAKE_CASE						       =    1024
										__SCREAMING_SNAKE_CASE						       =    4096
										__SCREAMING_SNAKE_CASE						       =    16
										__SCREAMING_SNAKE_CASE						       =    24
										__SCREAMING_SNAKE_CASE						       =    768
										__SCREAMING_SNAKE_CASE						       =    3072

					if model_name == "xclip-large-patch14-16-frames":
										__SCREAMING_SNAKE_CASE						       =    336

					__SCREAMING_SNAKE_CASE						       =    XCLIPConfig.from_text_vision_configs(lowerCAmelCase_  ,						lowerCAmelCase_       )

					if "large" in model_name:
										__SCREAMING_SNAKE_CASE						       =    768

					return config




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					if name == "token_embedding.weight":
										__SCREAMING_SNAKE_CASE						       =    name.replace("token_embedding.weight"  ,						"text_model.embeddings.token_embedding.weight"       )
					if name == "positional_embedding":
										__SCREAMING_SNAKE_CASE						       =    name.replace("positional_embedding"  ,						"text_model.embeddings.position_embedding.weight"       )
					if "ln_1" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("ln_1"  ,						"layer_norm1"       )
					if "ln_2" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("ln_2"  ,						"layer_norm2"       )
					if "c_fc" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("c_fc"  ,						"fc1"       )
					if "c_proj" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("c_proj"  ,						"fc2"       )
					if name.startswith("transformer.resblocks"       ):
										__SCREAMING_SNAKE_CASE						       =    name.replace("transformer.resblocks"  ,						"text_model.encoder.layers"       )
					if "attn.out_proj" in name and "message" not in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("attn.out_proj"  ,						"self_attn.out_proj"       )
					if "ln_final" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("ln_final"  ,						"text_model.final_layer_norm"       )
					# visual encoder
					if name == "visual.class_embedding":
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.class_embedding"  ,						"vision_model.embeddings.class_embedding"       )
					if name == "visual.positional_embedding":
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.positional_embedding"  ,						"vision_model.embeddings.position_embedding.weight"       )
					if name.startswith("visual.transformer.resblocks"       ):
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.transformer.resblocks"  ,						"vision_model.encoder.layers"       )
					if "visual.conv1" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.conv1"  ,						"vision_model.embeddings.patch_embedding"       )
					if "visual.ln_pre" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.ln_pre"  ,						"vision_model.pre_layernorm"       )
					if "visual.ln_post" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.ln_post"  ,						"vision_model.post_layernorm"       )
					if "visual.proj" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("visual.proj"  ,						"visual_projection.weight"       )
					if "text_projection" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("text_projection"  ,						"text_projection.weight"       )
					# things on top
					if "prompts_visual_proj" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("prompts_visual_proj"  ,						"prompts_visual_projection"       )
					if "prompts_visual_ln" in name:
										__SCREAMING_SNAKE_CASE						       =    name.replace("prompts_visual_ln"  ,						"prompts_visual_layernorm"       )
					# mit
					if name == "mit.positional_embedding":
										__SCREAMING_SNAKE_CASE						       =    name.replace("positional"  ,						"position"       )
					if name.startswith("mit.resblocks"       ):
										__SCREAMING_SNAKE_CASE						       =    name.replace("mit.resblocks"  ,						"mit.encoder.layers"       )
					# prompts generator
					if name.startswith("prompts_generator.norm"       ):
										__SCREAMING_SNAKE_CASE						       =    name.replace("prompts_generator.norm"  ,						"prompts_generator.layernorm"       )

					return name




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					for key in orig_state_dict.copy().keys():
										__SCREAMING_SNAKE_CASE						       =    orig_state_dict.pop(lowerCAmelCase_       )

										if "attn.in_proj" in key:
															__SCREAMING_SNAKE_CASE						       =    key.split("."       )
															if key.startswith("visual"       ):
																				__SCREAMING_SNAKE_CASE						       =    key_split[3]
																				__SCREAMING_SNAKE_CASE						       =    config.vision_config.hidden_size
																				if "message_attn" in key:
																									if "weight" in key:
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    :dim, :
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    dim : dim * 2, :
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    -dim:, :
																														]
																									else:
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    :dim
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    dim : dim * 2
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    -dim:
																														]
																				else:
																									if "weight" in key:
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    :dim, :
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    dim : dim * 2, :
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    -dim:, :
																														]
																									else:
																														__SCREAMING_SNAKE_CASE						       =    val[:dim]
																														__SCREAMING_SNAKE_CASE						       =    val[
																														    dim : dim * 2
																														]
																														__SCREAMING_SNAKE_CASE						       =    val[-dim:]
															elif key.startswith("mit"       ):
																				__SCREAMING_SNAKE_CASE						       =    key_split[2]
																				__SCREAMING_SNAKE_CASE						       =    config.vision_config.mit_hidden_size
																				if "weight" in key:
																									__SCREAMING_SNAKE_CASE						       =    val[:dim, :]
																									__SCREAMING_SNAKE_CASE						       =    val[dim : dim * 2, :]
																									__SCREAMING_SNAKE_CASE						       =    val[-dim:, :]
																				else:
																									__SCREAMING_SNAKE_CASE						       =    val[:dim]
																									__SCREAMING_SNAKE_CASE						       =    val[dim : dim * 2]
																									__SCREAMING_SNAKE_CASE						       =    val[-dim:]
															else:
																				__SCREAMING_SNAKE_CASE						       =    key_split[2]
																				__SCREAMING_SNAKE_CASE						       =    config.text_config.hidden_size
																				if "weight" in key:
																									__SCREAMING_SNAKE_CASE						       =    val[:dim, :]
																									__SCREAMING_SNAKE_CASE						       =    val[
																									    dim : dim * 2, :
																									]
																									__SCREAMING_SNAKE_CASE						       =    val[-dim:, :]
																				else:
																									__SCREAMING_SNAKE_CASE						       =    val[:dim]
																									__SCREAMING_SNAKE_CASE						       =    val[
																									    dim : dim * 2
																									]
																									__SCREAMING_SNAKE_CASE						       =    val[-dim:]
										else:
															__SCREAMING_SNAKE_CASE						       =    rename_key(lowerCAmelCase_       )
															if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
																				__SCREAMING_SNAKE_CASE						       =    val.T
															__SCREAMING_SNAKE_CASE						       =    val

					return orig_state_dict




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					if num_frames == 8:
										__SCREAMING_SNAKE_CASE						       =    "eating_spaghetti_8_frames.npy"
					elif num_frames == 16:
										__SCREAMING_SNAKE_CASE						       =    "eating_spaghetti.npy"
					elif num_frames == 32:
										__SCREAMING_SNAKE_CASE						       =    "eating_spaghetti_32_frames.npy"
					__SCREAMING_SNAKE_CASE						       =    hf_hub_download(
					    repo_id="hf-internal-testing/spaghetti-video"  ,						filename=lowerCAmelCase_  ,						repo_type="dataset"  ,						)
					__SCREAMING_SNAKE_CASE						       =    np.load(lowerCAmelCase_       )
					return list(lowerCAmelCase_       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=False       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    {
					    # fully supervised kinetics-400 checkpoints
					    "xclip-base-patch32": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth",
					    "xclip-base-patch32-16-frames": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"
					    ),
					    "xclip-base-patch16": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth",
					    "xclip-base-patch16-16-frames": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"
					    ),
					    "xclip-large-patch14": "https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb",
					    "xclip-large-patch14-16-frames": "https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f",
					    # fully supervised kinetics-600 checkpoints
					    "xclip-base-patch16-kinetics-600": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"
					    ),
					    "xclip-base-patch16-kinetics-600-16-frames": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"
					    ),
					    "xclip-large-patch14-kinetics-600": "https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be",
					    # few shot
					    "xclip-base-patch16-hmdb-2-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"
					    ),
					    "xclip-base-patch16-hmdb-4-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"
					    ),
					    "xclip-base-patch16-hmdb-8-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"
					    ),
					    "xclip-base-patch16-hmdb-16-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"
					    ),
					    "xclip-base-patch16-ucf-2-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"
					    ),
					    "xclip-base-patch16-ucf-4-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"
					    ),
					    "xclip-base-patch16-ucf-8-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"
					    ),
					    "xclip-base-patch16-ucf-16-shot": (
					        "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"
					    ),
					    # zero shot
					    "xclip-base-patch16-zero-shot": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth",
					}

					__SCREAMING_SNAKE_CASE						       =    model_to_url[model_name]
					__SCREAMING_SNAKE_CASE						       =    8
					if "16-frames" in model_name:
										__SCREAMING_SNAKE_CASE						       =    16
					elif "shot" in model_name:
										__SCREAMING_SNAKE_CASE						       =    32

					__SCREAMING_SNAKE_CASE						       =    get_xclip_config(lowerCAmelCase_  ,						lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    XCLIPModel(lowerCAmelCase_       )
					model.eval()

					if "drive" in checkpoint_url:
										__SCREAMING_SNAKE_CASE						       =    "pytorch_model.bin"
										gdown.cached_download(lowerCAmelCase_  ,						lowerCAmelCase_  ,						quiet=lowerCAmelCase_       )
										__SCREAMING_SNAKE_CASE						       =    torch.load(lowerCAmelCase_  ,						map_location="cpu"       )["model"]
					else:
										__SCREAMING_SNAKE_CASE						       =    torch.hub.load_state_dict_from_url(lowerCAmelCase_       )["model"]

					__SCREAMING_SNAKE_CASE						       =    convert_state_dict(lowerCAmelCase_  ,						lowerCAmelCase_       )

					__SCREAMING_SNAKE_CASE						       =    XCLIPModel(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE						       =    model.load_state_dict(lowerCAmelCase_  ,						strict=lowerCAmelCase_       )
					assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
					model.eval()

					__SCREAMING_SNAKE_CASE						       =    336 if model_name == "xclip-large-patch14-16-frames" else 224
					__SCREAMING_SNAKE_CASE						       =    VideoMAEImageProcessor(size=lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"       )
					__SCREAMING_SNAKE_CASE						       =    CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32"       )
					__SCREAMING_SNAKE_CASE						       =    XCLIPProcessor(image_processor=lowerCAmelCase_  ,						tokenizer=lowerCAmelCase_       )

					__SCREAMING_SNAKE_CASE						       =    prepare_video(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    processor(
					    text=["playing sports", "eating spaghetti", "go shopping"]  ,						videos=lowerCAmelCase_  ,						return_tensors="pt"  ,						padding=lowerCAmelCase_       )

					print("Shape of pixel values:"  ,						inputs.pixel_values.shape       )

					with torch.no_grad():
										__SCREAMING_SNAKE_CASE						       =    model(**lowerCAmelCase_       )

					# Verify outputs
					__SCREAMING_SNAKE_CASE						       =    outputs.logits_per_video
					__SCREAMING_SNAKE_CASE						       =    logits_per_video.softmax(dim=1       )
					print("Probs:"  ,						lowerCAmelCase_       )
					# kinetics-400
					if model_name == "xclip-base-patch32":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0019, 0.9951, 0.0030]]       )
					elif model_name == "xclip-base-patch32-16-frames":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[7.09_99E-04, 9.98_83E-01, 4.55_80E-04]]       )
					elif model_name == "xclip-base-patch16":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0083, 0.9681, 0.0236]]       )
					elif model_name == "xclip-base-patch16-16-frames":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[7.69_37E-04, 9.97_28E-01, 1.94_73E-03]]       )
					elif model_name == "xclip-large-patch14":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0062, 0.9864, 0.0075]]       )
					elif model_name == "xclip-large-patch14-16-frames":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[3.38_77E-04, 9.99_37E-01, 2.88_88E-04]]       )
					# kinetics-600
					elif model_name == "xclip-base-patch16-kinetics-600":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0555, 0.8914, 0.0531]]       )
					elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[3.85_54E-04, 9.99_29E-01, 3.27_54E-04]]       )
					elif model_name == "xclip-large-patch14-kinetics-600":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0036, 0.9920, 0.0045]]       )
					# few shot
					elif model_name == "xclip-base-patch16-hmdb-2-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[7.18_90E-06, 9.99_94E-01, 5.65_59E-05]]       )
					elif model_name == "xclip-base-patch16-hmdb-4-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[1.03_20E-05, 9.99_93E-01, 6.24_35E-05]]       )
					elif model_name == "xclip-base-patch16-hmdb-8-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[4.13_77E-06, 9.99_90E-01, 9.83_86E-05]]       )
					elif model_name == "xclip-base-patch16-hmdb-16-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[4.13_47E-05, 9.99_62E-01, 3.34_11E-04]]       )
					elif model_name == "xclip-base-patch16-ucf-2-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[8.58_57E-05, 9.99_28E-01, 6.32_91E-04]]       )
					elif model_name == "xclip-base-patch16-ucf-4-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[8.58_57E-05, 9.99_28E-01, 6.32_91E-04]]       )
					elif model_name == "xclip-base-patch16-ucf-8-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[0.0027, 0.9904, 0.0070]]       )
					elif model_name == "xclip-base-patch16-ucf-16-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[9.82_19E-04, 9.95_93E-01, 3.08_63E-03]]       )
					# zero shot
					elif model_name == "xclip-base-patch16-zero-shot":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor([[3.50_82E-04, 9.97_85E-01, 1.79_66E-03]]       )
					else:
										raise ValueError(f"""Model name {model_name} not supported"""       )
					assert torch.allclose(lowerCAmelCase_  ,						lowerCAmelCase_  ,						atol=1E-3       )
					print("Looks ok!"       )

					if pytorch_dump_folder_path is not None:
										print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""       )
										model.save_pretrained(lowerCAmelCase_       )

					if push_to_hub:
										print("Pushing model, processor and slow tokenizer files to the hub..."       )
										model.push_to_hub(lowerCAmelCase_  ,						organization="nielsr"       )
										processor.push_to_hub(lowerCAmelCase_  ,						organization="nielsr"       )
										slow_tokenizer.push_to_hub(lowerCAmelCase_  ,						organization="nielsr"       )


if __name__ == "__main__":
		a__    :							List[Any]            =					argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--model_name''',
		    default='''xclip-base-patch32''',
		    type=str,
		    help='''Name of the model.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
		)
		parser.add_argument(
		    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
		)

		a__    :							Dict            =					parser.parse_args()
		convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




"""simple docstring"""







from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					return math.sqrt(sum(pow(a - b  ,						2       ) for a, b in zip(lowerCAmelCase_  ,						lowerCAmelCase_       )       )       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					if dataset.ndim != value_array.ndim:
										__SCREAMING_SNAKE_CASE						       =    (
										    "Wrong input data's dimensions... "
										    f"""dataset : {dataset.ndim}, value_array : {value_array.ndim}"""
										)
										raise ValueError(lowerCAmelCase_       )

					try:
										if dataset.shape[1] != value_array.shape[1]:
															__SCREAMING_SNAKE_CASE						       =    (
															    "Wrong input data's shape... "
															    f"""dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}"""
															)
															raise ValueError(lowerCAmelCase_       )
					except IndexError:
										if dataset.ndim != value_array.ndim:
															raise TypeError("Wrong shape"       )

					if dataset.dtype != value_array.dtype:
										__SCREAMING_SNAKE_CASE						       =    (
										    "Input data have different datatype... "
										    f"""dataset : {dataset.dtype}, value_array : {value_array.dtype}"""
										)
										raise TypeError(lowerCAmelCase_       )

					__SCREAMING_SNAKE_CASE						       =    []

					for value in value_array:
										__SCREAMING_SNAKE_CASE						       =    euclidean(lowerCAmelCase_  ,						dataset[0]       )
										__SCREAMING_SNAKE_CASE						       =    dataset[0].tolist()

										for dataset_value in dataset[1:]:
															__SCREAMING_SNAKE_CASE						       =    euclidean(lowerCAmelCase_  ,						lowerCAmelCase_       )

															if dist > temp_dist:
																				__SCREAMING_SNAKE_CASE						       =    temp_dist
																				__SCREAMING_SNAKE_CASE						       =    dataset_value.tolist()

										answer.append([vector, dist]       )

					return answer




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					return np.dot(lowerCAmelCase_  ,						lowerCAmelCase_       ) / (norm(lowerCAmelCase_       ) * norm(lowerCAmelCase_       ))


if __name__ == "__main__":
		import doctest

		doctest.testmod()
