

"""simple docstring"""





import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


_a							=							{
    'iou_prediction_head.layers.0': 'iou_prediction_head.proj_in',
    'iou_prediction_head.layers.1': 'iou_prediction_head.layers.0',
    'iou_prediction_head.layers.2': 'iou_prediction_head.proj_out',
    'mask_decoder.output_upscaling.0': 'mask_decoder.upscale_conv1',
    'mask_decoder.output_upscaling.1': 'mask_decoder.upscale_layer_norm',
    'mask_decoder.output_upscaling.3': 'mask_decoder.upscale_conv2',
    'mask_downscaling.0': 'mask_embed.conv1',
    'mask_downscaling.1': 'mask_embed.layer_norm1',
    'mask_downscaling.3': 'mask_embed.conv2',
    'mask_downscaling.4': 'mask_embed.layer_norm2',
    'mask_downscaling.6': 'mask_embed.conv3',
    'point_embeddings': 'point_embed',
    'pe_layer.positional_encoding_gaussian_matrix': 'shared_embedding.positional_embedding',
    'image_encoder': 'vision_encoder',
    'neck.0': 'neck.conv1',
    'neck.1': 'neck.layer_norm1',
    'neck.2': 'neck.conv2',
    'neck.3': 'neck.layer_norm2',
    'patch_embed.proj': 'patch_embed.projection',
    '.norm': '.layer_norm',
    'blocks': 'layers',
}




def   _A  (  UpperCamelCase_					:	Any)     ->						str:
   '''simple docstring'''


   __lowercase								=						{}
   state_dict.pop("pixel_mean",      UpperCamelCase_)
   state_dict.pop("pixel_std",      UpperCamelCase_)

   __lowercase								=						r".*.output_hypernetworks_mlps.(\d+).layers.(\d+).*"

   for key, value in state_dict.items():
      for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
         if key_to_modify in key:
            __lowercase								=						key.replace(UpperCamelCase_,      UpperCamelCase_)

      if re.match(UpperCamelCase_,      UpperCamelCase_):
         __lowercase								=						int(re.match(UpperCamelCase_,      UpperCamelCase_).group(2))
         if layer_nb == 0:
            __lowercase								=						key.replace("layers.0",      "proj_in")
         elif layer_nb == 1:
            __lowercase								=						key.replace("layers.1",      "layers.0")
         elif layer_nb == 2:
            __lowercase								=						key.replace("layers.2",      "proj_out")

      __lowercase								=						value

   __lowercase								=						model_state_dict[
       "prompt_encoder.shared_embedding.positional_embedding"
   ]

   return model_state_dict




def   _A  (  UpperCamelCase_					:	Tuple,      UpperCamelCase_					:	Tuple,      UpperCamelCase_					:	int,      UpperCamelCase_					:	int="ybelkada/segment-anything")     ->						str:
   '''simple docstring'''


   __lowercase								=						hf_hub_download(UpperCamelCase_,      F"""checkpoints/{model_name}.pth""")

   if "sam_vit_b" in model_name:
      __lowercase								=						SamConfig()
   elif "sam_vit_l" in model_name:
      __lowercase								=						SamVisionConfig(
          hidden_size=1024,      num_hidden_layers=24,      num_attention_heads=16,      global_attn_indexes=[5, 11, 17, 23],      )

      __lowercase								=						SamConfig(
          vision_config=UpperCamelCase_,      )
   elif "sam_vit_h" in model_name:
      __lowercase								=						SamVisionConfig(
          hidden_size=1280,      num_hidden_layers=32,      num_attention_heads=16,      global_attn_indexes=[7, 15, 23, 31],      )

      __lowercase								=						SamConfig(
          vision_config=UpperCamelCase_,      )

   __lowercase								=						torch.load(UpperCamelCase_,      map_location="cpu")
   __lowercase								=						replace_keys(UpperCamelCase_)

   __lowercase								=						SamImageProcessor()

   __lowercase								=						SamProcessor(image_processor=UpperCamelCase_)
   __lowercase								=						SamModel(UpperCamelCase_)

   hf_model.load_state_dict(UpperCamelCase_)
   __lowercase								=						hf_model.to("cuda")

   __lowercase								=						"https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
   __lowercase								=						Image.open(requests.get(UpperCamelCase_,      stream=UpperCamelCase_).raw).convert("RGB")

   __lowercase								=						[[[400, 650]]]
   __lowercase								=						[[1]]

   __lowercase								=						processor(images=np.array(UpperCamelCase_),      return_tensors="pt").to("cuda")

   with torch.no_grad():
      __lowercase								=						hf_model(**UpperCamelCase_)
   __lowercase								=						output.iou_scores.squeeze()

   if model_name == "sam_vit_h_4b8939":
      assert scores[-1].item() == 0.579_890_251_159_668

      __lowercase								=						processor(
          images=np.array(UpperCamelCase_),      input_points=UpperCamelCase_,      input_labels=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						output.iou_scores.squeeze()

      assert scores[-1].item() == 0.9_712_603_092_193_604

      __lowercase								=						((75, 275, 1725, 850),)

      __lowercase								=						processor(images=np.array(UpperCamelCase_),      input_boxes=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						output.iou_scores.squeeze()

      assert scores[-1].item() == 0.8_686_015_605_926_514

      # Test with 2 points and 1 image.
      __lowercase								=						[[[400, 650], [800, 650]]]
      __lowercase								=						[[1, 1]]

      __lowercase								=						processor(
          images=np.array(UpperCamelCase_),      input_points=UpperCamelCase_,      input_labels=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						output.iou_scores.squeeze()

      assert scores[-1].item() == 0.9_936_047_792_434_692


if __name__ == "__main__":
   _a							=							argparse.ArgumentParser()
   _a							=							['sam_vit_b_01ec64', 'sam_vit_h_4b8939', 'sam_vit_l_0b3195']
   parser.add_argument(
       '--model_name',
       default='sam_vit_h_4b8939',
       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',
   )
   parser.add_argument(
       '--model_hub_id',
       default='ybelkada/segment-anything',
       choices=choices,
       type=str,
       help='Path to hf config.json of model to convert',
   )

   _a							=							parser.parse_args()

   convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)


"""simple docstring"""





import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812




def   _A  (  )     ->						None:
   '''simple docstring'''


   print("Making key files...")
   make_key_files("rsa",      1024)
   print("Key files generation successful.")




def   _A  (  UpperCamelCase_					:	int)     ->						tuple[tuple[int, int], tuple[int, int]]:
   '''simple docstring'''


   print("Generating prime p...")
   __lowercase								=						rabinMiller.generate_large_prime(UpperCamelCase_)
   print("Generating prime q...")
   __lowercase								=						rabinMiller.generate_large_prime(UpperCamelCase_)
   __lowercase								=						p * q

   print("Generating e that is relatively prime to (p - 1) * (q - 1)...")
   while True:
      __lowercase								=						random.randrange(2 ** (key_size - 1),      2 ** (key_size))
      if cryptoMath.gcd(UpperCamelCase_,      (p - 1) * (q - 1)) == 1:
         break

   print("Calculating d that is mod inverse of e...")
   __lowercase								=						cryptoMath.find_mod_inverse(UpperCamelCase_,      (p - 1) * (q - 1))

   __lowercase								=						(n, e)
   __lowercase								=						(n, d)
   return (public_key, private_key)




def   _A  (  UpperCamelCase_					:	str,      UpperCamelCase_					:	int)     ->						None:
   '''simple docstring'''


   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()

   __lowercase		,__lowercase								=						generate_key(UpperCamelCase_)
   print(F"""\nWriting public key to file {name}_pubkey.txt...""")
   with open(F"""{name}_pubkey.txt""",      "w") as out_file:
      out_file.write(F"""{key_size},{public_key[0]},{public_key[1]}""")

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


if __name__ == "__main__":
   main()




