






import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
		UpperCamelCase_:      Dict					   =       pt_attn_layer.in_proj_weight.chunk(3			,					dim=0						)
		UpperCamelCase_:      Optional[Any]					   =       pt_attn_layer.in_proj_bias.chunk(3			,					dim=0						)

		UpperCamelCase_:      int					   =       pt_attn_layer.out_proj.weight
		UpperCamelCase_:      Union[str, Any]					   =       pt_attn_layer.out_proj.bias

		UpperCamelCase_:      List[Any]					   =       q_proj
		UpperCamelCase_:      Tuple					   =       q_proj_bias

		UpperCamelCase_:      List[str]					   =       k_proj
		UpperCamelCase_:      Dict					   =       k_proj_bias

		UpperCamelCase_:      Tuple					   =       v_proj
		UpperCamelCase_:      Optional[int]					   =       v_proj_bias

		UpperCamelCase_:      Union[str, Any]					   =       out_proj_weights
		UpperCamelCase_:      Dict					   =       out_proj_bias

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Optional[int]:
		copy_linear(hf_mlp.fca			,					pt_mlp.c_fc						)
		copy_linear(hf_mlp.fca			,					pt_mlp.c_proj						)

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Optional[Any]:
		UpperCamelCase_:      Tuple					   =       pt_linear.weight
		UpperCamelCase_:      Dict					   =       pt_linear.bias

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       str:
		# 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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       List[Any]:
		for hf_layer, pt_layer in zip(UpperCAmelCase__			,					UpperCAmelCase__						):
				copy_layer(UpperCAmelCase__			,					UpperCAmelCase__						)

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
		# copy  embeds
		UpperCamelCase_:      int					   =       pt_model.token_embedding.weight
		UpperCamelCase_:      Union[str, Any]					   =       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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Tuple:
		# copy projection
		UpperCamelCase_:      Optional[Any]					   =       pt_model.text_projection.data.T

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

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Any:
		# copy projection
		UpperCamelCase_:      List[str]					   =       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_:      Optional[int]					   =       pt_model.visual.conva.weight.data
		UpperCamelCase_:      Optional[int]					   =       pt_model.visual.class_embedding
		UpperCamelCase_:      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 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__			,					UpperCAmelCase__=None						) ->       Dict:
		if config_path is not None:
				UpperCamelCase_:      Tuple					   =       CLIPConfig.from_pretrained(UpperCAmelCase__						)
		else:
				UpperCamelCase_:      List[Any]					   =       CLIPConfig(projection_dim=5_1_2			,					text_config={}			,					vision_config={}						)

		UpperCamelCase_:      Any					   =       CLIPModel(UpperCAmelCase__						).eval()

		UpperCamelCase_:      Any					   =       load(UpperCAmelCase__			,					device='cpu'			,					jit=UpperCAmelCase__						)
		UpperCamelCase_:      Any					   =       pt_model.eval()

		copy_text_model_and_projection(UpperCAmelCase__			,					UpperCAmelCase__						)
		copy_vison_model_and_projection(UpperCAmelCase__			,					UpperCAmelCase__						)
		UpperCamelCase_:      List[Any]					   =       pt_model.logit_scale

		UpperCamelCase_:      List[Any]					   =       torch.arange(0			,					7_7						).unsqueeze(0						)
		UpperCamelCase_:      int					   =       torch.randn(1			,					3			,					2_2_4			,					2_2_4						)

		UpperCamelCase_:      int					   =       hf_model(input_ids=UpperCAmelCase__			,					pixel_values=UpperCAmelCase__			,					return_dict=UpperCAmelCase__						)
		UpperCamelCase_:      Union[str, Any]					   =       hf_outputs.logits_per_image
		UpperCamelCase_:      Union[str, Any]					   =       hf_outputs.logits_per_text
		UpperCamelCase_:      List[str]					   =       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__":
			A_	:	List[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')
			A_	:	str				=				parser.parse_args()

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







from datetime import date

import requests

A_	:	Any				=				'https://api.carbonintensity.org.uk/intensity'

def 						snake_case      () ->       str:
  UpperCamelCase_:      Any					   =       requests.get(UpperCAmelCase__						).json()['data'][0]
  return last_half_hour["intensity"]["actual"]

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       list:
  return requests.get(F'''{BASE_URL}/{start}/{end}'''						).json()["data"]


if __name__ == "__main__":
   for entry in fetch_from_to(start=date(2020, 10, 1), end=date(2020, 10, 3)):
      print('from {from} to {to}: {intensity[actual]}'.format(**entry))
   print(F'''{fetch_last_half_hour() = }''')