"""simple docstring"""



import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD



def 					_lowerCamelCase(					):
       __a     				=  "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"
       __a     				=  Image.open(requests.get(a ,  stream=a							).raw							).convert("RGB"							)

       return image



def 					_lowerCamelCase(					a							):
       __a     				=  []
       # fmt: off

       # vision encoder
       rename_keys.append(("visual_encoder.cls_token", "vision_model.embeddings.class_embedding")							)
       rename_keys.append(("visual_encoder.pos_embed", "vision_model.embeddings.position_embedding")							)
       rename_keys.append(("visual_encoder.patch_embed.proj.weight", "vision_model.embeddings.patch_embedding.weight")							)
       rename_keys.append(("visual_encoder.patch_embed.proj.bias", "vision_model.embeddings.patch_embedding.bias")							)
       rename_keys.append(("ln_vision.weight", "vision_model.post_layernorm.weight")							)
       rename_keys.append(("ln_vision.bias", "vision_model.post_layernorm.bias")							)

       for i in range(config.vision_config.num_hidden_layers							):
              rename_keys.append((F"visual_encoder.blocks.{i}.norm1.weight", F"vision_model.encoder.layers.{i}.layer_norm1.weight")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.norm1.bias", F"vision_model.encoder.layers.{i}.layer_norm1.bias")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.norm2.weight", F"vision_model.encoder.layers.{i}.layer_norm2.weight")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.norm2.bias", F"vision_model.encoder.layers.{i}.layer_norm2.bias")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.attn.qkv.weight", F"vision_model.encoder.layers.{i}.self_attn.qkv.weight")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.weight", F"vision_model.encoder.layers.{i}.self_attn.projection.weight",)							)
              rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.bias", F"vision_model.encoder.layers.{i}.self_attn.projection.bias")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.weight", F"vision_model.encoder.layers.{i}.mlp.fc1.weight")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.bias", F"vision_model.encoder.layers.{i}.mlp.fc1.bias")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.weight", F"vision_model.encoder.layers.{i}.mlp.fc2.weight")							)
              rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.bias", F"vision_model.encoder.layers.{i}.mlp.fc2.bias")							)

       # QFormer
       rename_keys.append(("Qformer.bert.embeddings.LayerNorm.weight", "qformer.layernorm.weight")							)
       rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.layernorm.bias")							)

       # fmt: on
       return rename_keys



def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  dct.pop(a							)
       __a     				=  val



def 					_lowerCamelCase(					a ,  a							):
       for i in range(config.vision_config.num_hidden_layers							):
              # read in original q and v biases
              __a     				=  state_dict.pop(F"visual_encoder.blocks.{i}.attn.q_bias"							)
              __a     				=  state_dict.pop(F"visual_encoder.blocks.{i}.attn.v_bias"							)

              # next, set bias in the state dict
              __a     				=  torch.cat((q_bias, torch.zeros_like(a ,  requires_grad=a							), v_bias)							)
              __a     				=  qkv_bias



def 					_lowerCamelCase(					a ,  a							):
       __a     				=  3_6_4 if "coco" in model_name else 2_2_4
       __a     				=  BlipaVisionConfig(image_size=a							).to_dict()

       # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
       # seems like flan-T5 models don't have bos_token_id properly set?
       if "opt-2.7b" in model_name:
              __a     				=  OPTConfig.from_pretrained("facebook/opt-2.7b" ,  eos_token_id=a							).to_dict()
       elif "opt-6.7b" in model_name:
              __a     				=  OPTConfig.from_pretrained("facebook/opt-6.7b" ,  eos_token_id=a							).to_dict()
       elif "t5-xl" in model_name:
              __a     				=  TaConfig.from_pretrained("google/flan-t5-xl" ,  dense_act_fn="gelu" ,  bos_token_id=1							).to_dict()
       elif "t5-xxl" in model_name:
              __a     				=  TaConfig.from_pretrained("google/flan-t5-xxl" ,  dense_act_fn="gelu" ,  bos_token_id=1							).to_dict()

       __a     				=  BlipaConfig(vision_config=a ,  text_config=a							)

       return config, image_size



@torch.no_grad()
def 					_lowerCamelCase(					a ,  a=None ,  a=False							):
       __a     				=  (
           AutoTokenizer.from_pretrained("facebook/opt-2.7b"							)
           if "opt" in model_name
           else AutoTokenizer.from_pretrained("google/flan-t5-xl"							)
       )
       __a     				=  tokenizer("\n" ,  add_special_tokens=a							).input_ids[0]
       __a				, __a     				=  get_blipa_config(a ,  eos_token_id=a							)

       __a     				=  BlipaForConditionalGeneration(a							).eval()

       __a     				=  {
           "blip2-opt-2.7b": ("blip2_opt", "pretrain_opt2.7b"),
           "blip2-opt-6.7b": ("blip2_opt", "pretrain_opt6.7b"),
           "blip2-opt-2.7b-coco": ("blip2_opt", "caption_coco_opt2.7b"),
           "blip2-opt-6.7b-coco": ("blip2_opt", "caption_coco_opt6.7b"),
           "blip2-flan-t5-xl": ("blip2_t5", "pretrain_flant5xl"),
           "blip2-flan-t5-xl-coco": ("blip2_t5", "caption_coco_flant5xl"),
           "blip2-flan-t5-xxl": ("blip2_t5", "pretrain_flant5xxl"),
       }

       __a				, __a     				=  model_name_to_original[model_name]

       # load original model
       print("Loading original model..."							)
       __a     				=  "cuda" if torch.cuda.is_available() else "cpu"
       __a				, __a				, __a     				=  load_model_and_preprocess(
           name=a ,  model_type=a ,  is_eval=a ,  device=a							)
       original_model.eval()
       print("Done!"							)

       # update state dict keys
       __a     				=  original_model.state_dict()
       __a     				=  create_rename_keys(a							)
       for src, dest in rename_keys:
              rename_key(a ,  a ,  a							)

       # some keys can be renamed efficiently
       for key, val in state_dict.copy().items():
              __a     				=  state_dict.pop(a							)
              if key.startswith("Qformer.bert"							):
                     __a     				=  key.replace("Qformer.bert" ,  "qformer"							)
              if "attention.self" in key:
                     __a     				=  key.replace("self" ,  "attention"							)
              if "opt_proj" in key:
                     __a     				=  key.replace("opt_proj" ,  "language_projection"							)
              if "t5_proj" in key:
                     __a     				=  key.replace("t5_proj" ,  "language_projection"							)
              if key.startswith("opt"							):
                     __a     				=  key.replace("opt" ,  "language"							)
              if key.startswith("t5"							):
                     __a     				=  key.replace("t5" ,  "language"							)
              __a     				=  val

       # read in qv biases
       read_in_q_v_bias(a ,  a							)

       __a				, __a     				=  hf_model.load_state_dict(a ,  strict=a							)
       assert len(a							) == 0
       assert unexpected_keys == ["qformer.embeddings.position_ids"]

       __a     				=  load_demo_image()
       __a     				=  vis_processors["eval"](a							).unsqueeze(0							).to(a							)
       __a     				=  tokenizer(["\n"] ,  return_tensors="pt"							).input_ids.to(a							)

       # create processor
       __a     				=  BlipImageProcessor(
           size={"height": image_size, "width": image_size} ,  image_mean=a ,  image_std=a							)
       __a     				=  BlipaProcessor(image_processor=a ,  tokenizer=a							)
       __a     				=  processor(images=a ,  return_tensors="pt"							).pixel_values.to(a							)

       # make sure processor creates exact same pixel values
       assert torch.allclose(a ,  a							)

       original_model.to(a							)
       hf_model.to(a							)
       with torch.no_grad():
              if "opt" in model_name:
                     __a     				=  original_model({"image": original_pixel_values, "text_input": [""]}							).logits
                     __a     				=  hf_model(a ,  a							).logits
              else:
                     __a     				=  original_model(
                         {"image": original_pixel_values, "text_input": ["\n"], "text_output": ["\n"]}							).logits
                     __a     				=  input_ids.masked_fill(input_ids == tokenizer.pad_token_id ,  -1_0_0							)
                     __a     				=  hf_model(a ,  a ,  labels=a							).logits

       assert original_logits.shape == logits.shape
       print("First values of original logits:" ,  original_logits[0, :3, :3]							)
       print("First values of HF logits:" ,  logits[0, :3, :3]							)

       # assert values
       if model_name == "blip2-flan-t5-xl":
              __a     				=  torch.tensor(
                  [[-41.58_50, -4.44_40, -8.99_22], [-47.43_22, -5.91_43, -1.73_40]] ,  device=a							)
              assert torch.allclose(logits[0, :3, :3] ,  a ,  atol=1E-4							)
       elif model_name == "blip2-flan-t5-xl-coco":
              __a     				=  torch.tensor(
                  [[-57.01_09, -9.89_67, -12.62_80], [-68.65_78, -12.71_91, -10.50_65]] ,  device=a							)
       else:
              # cast to same type
              __a     				=  logits.dtype
              assert torch.allclose(original_logits.to(a							) ,  a ,  atol=1E-2							)
       print("Looks ok!"							)

       print("Generating a caption..."							)
       __a     				=  ""
       __a     				=  tokenizer(a ,  return_tensors="pt"							).input_ids.to(a							)

       __a     				=  original_model.generate({"image": original_pixel_values}							)
       __a     				=  hf_model.generate(
           a ,  a ,  do_sample=a ,  num_beams=5 ,  max_length=3_0 ,  min_length=1 ,  top_p=0.9 ,  repetition_penalty=1.0 ,  length_penalty=1.0 ,  temperature=1 ,  )
       print("Original generation:" ,  a							)
       __a     				=  input_ids.shape[1]
       __a     				=  processor.batch_decode(outputs[:, prompt_length:] ,  skip_special_tokens=a							)
       __a     				=  [text.strip() for text in output_text]
       print("HF generation:" ,  a							)

       if pytorch_dump_folder_path is not None:
              processor.save_pretrained(a							)
              hf_model.save_pretrained(a							)

       if push_to_hub:
              processor.push_to_hub(F"nielsr/{model_name}"							)
              hf_model.push_to_hub(F"nielsr/{model_name}"							)


if __name__ == "__main__":
   SCREAMING_SNAKE_CASE__:Tuple			=	argparse.ArgumentParser()
   SCREAMING_SNAKE_CASE__:Optional[int]			=	[
       """blip2-opt-2.7b""",
       """blip2-opt-6.7b""",
       """blip2-opt-2.7b-coco""",
       """blip2-opt-6.7b-coco""",
       """blip2-flan-t5-xl""",
       """blip2-flan-t5-xl-coco""",
       """blip2-flan-t5-xxl""",
   ]
   parser.add_argument(
       """--model_name""",
       default="""blip2-opt-2.7b""",
       choices=choices,
       type=str,
       help="""Path to hf config.json of model to convert""",
   )
   parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
   parser.add_argument(
       """--push_to_hub""",
       action="""store_true""",
       help="""Whether to push the model and processor to the hub after converting""",
   )

   SCREAMING_SNAKE_CASE__:str			=	parser.parse_args()

   convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

"""simple docstring"""



import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

SCREAMING_SNAKE_CASE__:List[str]			=	3



def 					_lowerCamelCase(					a							):
       print("Generating primitive root of p"							)
       while True:
              __a     				=  random.randrange(3 ,  a							)
              if pow(a ,  2 ,  a							) == 1:
                     continue
              if pow(a ,  a ,  a							) == 1:
                     continue
              return g



def 					_lowerCamelCase(					a							):
       print("Generating prime p..."							)
       __a     				=  rabin_miller.generate_large_prime(a							)  # select large prime number.
       __a     				=  primitive_root(a							)  # one primitive root on modulo p.
       __a     				=  random.randrange(3 ,  a							)  # private_key -> have to be greater than 2 for safety.
       __a     				=  cryptomath.find_mod_inverse(pow(a ,  a ,  a							) ,  a							)

       __a     				=  (key_size, e_a, e_a, p)
       __a     				=  (key_size, d)

       return public_key, private_key



def 					_lowerCamelCase(					a ,  a							):
       if os.path.exists(F"{name}_pubkey.txt"							) or os.path.exists(F"{name}_privkey.txt"							):
              print("\nWARNING:"							)
              print(
                  F"\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"
                  "Use a different name or delete these files and re-run this program."							)
              sys.exit()

       __a				, __a     				=  generate_key(a							)
       print(F"\nWriting public key to file {name}_pubkey.txt..."							)
       with open(F"{name}_pubkey.txt" ,  "w"							) as fo:
              fo.write(F"{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}"							)

       print(F"Writing private key to file {name}_privkey.txt..."							)
       with open(F"{name}_privkey.txt" ,  "w"							) as fo:
              fo.write(F"{private_key[0]},{private_key[1]}"							)



def 					_lowerCamelCase(					):
       print("Making key files..."							)
       make_key_files("elgamal" ,  2_0_4_8							)
       print("Key files generation successful"							)


if __name__ == "__main__":
   main()
