



"""simple docstring"""







import argparse
import pathlib
from pathlib import Path
from tempfile import TemporaryDirectory

import esm as esm_module
import torch
from esm.esmfold.va.misc import batch_encode_sequences as esmfold_encode_sequences
from esm.esmfold.va.pretrained import esmfold_va

from transformers.models.esm.configuration_esm import EsmConfig, EsmFoldConfig
from transformers.models.esm.modeling_esm import (
    EsmForMaskedLM,
    EsmForSequenceClassification,
    EsmIntermediate,
    EsmLayer,
    EsmOutput,
    EsmSelfAttention,
    EsmSelfOutput,
)
from transformers.models.esm.modeling_esmfold import EsmForProteinFolding
from transformers.models.esm.tokenization_esm import EsmTokenizer
from transformers.utils import logging


logging.set_verbosity_info()
lowercase__						:							Any        =      logging.get_logger(__name__)

lowercase__						:							Tuple        =      [
    (
        """protein1""",
        """MNGTEGPNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQHKKLRTPLNYILLNLAVADLFMVLGGFTSTLYTSLHGYFVFGPTGCNLEGFFATLGGEIALWSLVVLAIERYVVVCKPMSNFRFGENHAIMGVAFTWVMALACAAPPLAGWSRYIPEGLQCSCGIDYYTLKPEVNNESFVIYMFVVHFTIPMIIIFFCYGQLVFTVKEAAAQQQESATTQKAEKEVTRMVIIMVIAFLICWVPYASVAFYIFTHQGSNFGPIFMTIPAFFAKSAAIYNPVIYIMMNKQFRNCMLTTICCGKNPLGDDEASATVSKTETSQVAPA""",
    ),
    ("""protein2""", """MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLA"""),
    ("""protein3""", """MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLAGG"""),
    ("""protein4""", """MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLA"""),
]

lowercase__						:							List[str]        =      {
    """esm1b_t33_650M_UR50S""": esm_module.pretrained.esm1b_t33_650M_UR50S,
    """esm1v_t33_650M_UR90S_1""": esm_module.pretrained.esm1v_t33_650M_UR90S_1,
    """esm1v_t33_650M_UR90S_2""": esm_module.pretrained.esm1v_t33_650M_UR90S_2,
    """esm1v_t33_650M_UR90S_3""": esm_module.pretrained.esm1v_t33_650M_UR90S_3,
    """esm1v_t33_650M_UR90S_4""": esm_module.pretrained.esm1v_t33_650M_UR90S_4,
    """esm1v_t33_650M_UR90S_5""": esm_module.pretrained.esm1v_t33_650M_UR90S_5,
    """esm2_t48_15B_UR50D""": esm_module.pretrained.esm2_t48_15B_UR50D,
    """esm2_t36_3B_UR50D""": esm_module.pretrained.esm2_t36_3B_UR50D,
    """esm2_t33_650M_UR50D""": esm_module.pretrained.esm2_t33_650M_UR50D,
    """esm2_t30_150M_UR50D""": esm_module.pretrained.esm2_t30_150M_UR50D,
    """esm2_t12_35M_UR50D""": esm_module.pretrained.esm2_t12_35M_UR50D,
    """esm2_t6_8M_UR50D""": esm_module.pretrained.esm2_t6_8M_UR50D,
    """esmfold_v1""": esmfold_va,
}

lowercase__						:							List[str]        =      list("""ARNDCQEGHILKMFPSTWYV""")

lowercase__						:							List[str]        =      restypes + ["""X"""]
lowercase__						:							Dict        =      restypes_with_x + ["""<pad>""", """<mask>""", """<cls>""", """<sep>""", """<eos>"""]

def 							UpperCamelCase_       (       )		->  List[str]:

  """simple docstring"""




  with TemporaryDirectory() as tempdir:
    lowerCAmelCase_  :							Dict								=					'\n'.join(UpperCamelCase_		)
    lowerCAmelCase_  :							Any								=					Path(UpperCamelCase_		) / 'vocab.txt'
    vocab_file.write_text(UpperCamelCase_		)
    lowerCAmelCase_  :							Any								=					EsmTokenizer(vocab_file=str(UpperCamelCase_		)		)
  lowerCAmelCase_  :							Optional[Any]								=					0  # Overlaps with 'A' but that seems to be what they want
  return hf_tokenizer

def 							UpperCamelCase_       (       lowerCAmelCase__ :							Any       ,  lowerCAmelCase__ :							str		)		->  List[str]:

  """simple docstring"""




  lowerCAmelCase_  :							List[str]								=					our_module.load_state_dict(original_module.state_dict()		)
  if status.missing_keys:
    raise ValueError(f"Missing keys: {status.missing_keys}"		)
  if status.unexpected_keys:
    raise ValueError(f"Unexpected keys: {status.unexpected_keys}"		)

def 							UpperCamelCase_       (       lowerCAmelCase__ :							str       ,  lowerCAmelCase__ :							str       ,  lowerCAmelCase__ :							bool       ,  lowerCAmelCase__ :							str       ,  lowerCAmelCase__ :							str		)		->  Tuple:

  """simple docstring"""




  if model.startswith('esmfold'		):
    lowerCAmelCase_  :							str								=					MODEL_MAPPING[model]()
  else:
    lowerCAmelCase_		,lowerCAmelCase_  :							Tuple								=					MODEL_MAPPING[model]()
  esm.eval()  # disable dropout

  if model.startswith('esmfold'		):
    lowerCAmelCase_  :							str								=					esm.esm.embed_dim
    lowerCAmelCase_  :							str								=					esm.esm.num_layers
    lowerCAmelCase_  :							Any								=					esm.esm.attention_heads
    lowerCAmelCase_  :							Tuple								=					4 * embed_dim
    lowerCAmelCase_  :							List[str]								=					esm.esm.token_dropout
    lowerCAmelCase_  :							Tuple								=					False  # This code path does not exist in ESM-2
    lowerCAmelCase_  :							Any								=					'rotary'
    lowerCAmelCase_  :							str								=					True
    lowerCAmelCase_  :							List[str]								=					EsmFoldConfig()
    for key, val in esm.cfg.items():
      if hasattr(UpperCamelCase_       ,  UpperCamelCase_		) and key != "trunk":
        setattr(UpperCamelCase_       ,  UpperCamelCase_       ,  UpperCamelCase_		)
    for key, val in esm.cfg.trunk.items():
      if hasattr(esmfold_config.trunk       ,  UpperCamelCase_		) and key != "structure_module":
        setattr(esmfold_config.trunk       ,  UpperCamelCase_       ,  UpperCamelCase_		)
    for key, val in esm.cfg.trunk.structure_module.items():
      if hasattr(esmfold_config.trunk.structure_module       ,  UpperCamelCase_		):
        setattr(esmfold_config.trunk.structure_module       ,  UpperCamelCase_       ,  UpperCamelCase_		)
  elif hasattr(UpperCamelCase_       ,  'args'		):
    # Indicates an ESM-1b or ESM-1v model
    lowerCAmelCase_  :							Tuple								=					esm.args.embed_dim
    lowerCAmelCase_  :							List[Any]								=					esm.args.layers
    lowerCAmelCase_  :							Optional[Any]								=					esm.args.attention_heads
    lowerCAmelCase_  :							Dict								=					esm.args.ffn_embed_dim
    lowerCAmelCase_  :							Union[str, Any]								=					esm.args.token_dropout
    lowerCAmelCase_  :							Union[str, Any]								=					True if esm.emb_layer_norm_before else False
    lowerCAmelCase_  :							Dict								=					'absolute'
    lowerCAmelCase_  :							Union[str, Any]								=					False
    lowerCAmelCase_  :							Any								=					None
  else:
    # Indicates an ESM-2 model
    lowerCAmelCase_  :							List[Any]								=					esm.embed_dim
    lowerCAmelCase_  :							Optional[Any]								=					esm.num_layers
    lowerCAmelCase_  :							int								=					esm.attention_heads
    lowerCAmelCase_  :							Any								=					4 * embed_dim  # This is hardcoded in ESM-2
    lowerCAmelCase_  :							Optional[Any]								=					esm.token_dropout
    lowerCAmelCase_  :							List[Any]								=					False  # This code path does not exist in ESM-2
    lowerCAmelCase_  :							Any								=					'rotary'
    lowerCAmelCase_  :							Union[str, Any]								=					False
    lowerCAmelCase_  :							int								=					None

  if is_folding_model:
    lowerCAmelCase_  :							Optional[int]								=					esm.esm.alphabet
  lowerCAmelCase_  :							Any								=					tuple(alphabet.all_toks		)
  lowerCAmelCase_  :							List[str]								=					alphabet.mask_idx
  lowerCAmelCase_  :							int								=					alphabet.padding_idx

  if is_folding_model:
    lowerCAmelCase_  :							List[str]								=					esm.esm
  else:
    lowerCAmelCase_  :							List[Any]								=					esm

  lowerCAmelCase_  :							Optional[int]								=					EsmConfig(
      vocab_size=original_esm_model.embed_tokens.num_embeddings       ,  mask_token_id=UpperCamelCase_       ,  hidden_size=UpperCamelCase_       ,  num_hidden_layers=UpperCamelCase_       ,  num_attention_heads=UpperCamelCase_       ,  intermediate_size=UpperCamelCase_       ,  max_position_embeddings=1026       ,  layer_norm_eps=1e-5       ,  attention_probs_dropout_prob=0.0       ,  hidden_dropout_prob=0.0       ,  pad_token_id=UpperCamelCase_       ,  emb_layer_norm_before=UpperCamelCase_       ,  token_dropout=UpperCamelCase_       ,  position_embedding_type=UpperCamelCase_       ,  is_folding_model=UpperCamelCase_       ,  esmfold_config=UpperCamelCase_       ,  vocab_list=UpperCamelCase_       ,  )
  if classification_head:
    lowerCAmelCase_  :							List[str]								=					esm.classification_heads['mnli'].out_proj.weight.shape[0]
  print('Our ESM config:'       ,  UpperCamelCase_		)

  if model.startswith('esmfold'		):
    lowerCAmelCase_  :							int								=					EsmForProteinFolding
  elif classification_head:
    lowerCAmelCase_  :							List[str]								=					EsmForSequenceClassification
  else:
    lowerCAmelCase_  :							Optional[Any]								=					EsmForMaskedLM
  lowerCAmelCase_  :							int								=					model_class(UpperCamelCase_		)
  model.eval()

  # Now let's copy all the weights.
  # Embeddings
  lowerCAmelCase_  :							Optional[int]								=					original_esm_model.embed_tokens.weight
  if position_embedding_type == "absolute":
    lowerCAmelCase_  :							int								=					original_esm_model.embed_positions.weight

  if config.emb_layer_norm_before:
    lowerCAmelCase_  :							str								=					original_esm_model.emb_layer_norm_before.weight
    lowerCAmelCase_  :							Optional[int]								=					original_esm_model.emb_layer_norm_before.bias

  lowerCAmelCase_  :							int								=					original_esm_model.emb_layer_norm_after.weight
  lowerCAmelCase_  :							Any								=					original_esm_model.emb_layer_norm_after.bias

  for i in range(config.num_hidden_layers		):
    # Encoder: start of layer
    lowerCAmelCase_  :							str								=					model.esm.encoder.layer[i]
    # esm_layer: TransformerSentenceEncoderLayer = original_esm_model.layers[i]
    lowerCAmelCase_  :							Tuple								=					original_esm_model.layers[i]

    # self attention
    lowerCAmelCase_  :							Optional[Any]								=					layer.attention.self
    assert (
        esm_layer.self_attn.k_proj.weight.data.shape
        == esm_layer.self_attn.q_proj.weight.data.shape
        == esm_layer.self_attn.v_proj.weight.data.shape
        == torch.Size((config.hidden_size, config.hidden_size)		)
    )

    lowerCAmelCase_  :							List[str]								=					esm_layer.self_attn.q_proj.weight
    lowerCAmelCase_  :							Dict								=					esm_layer.self_attn.q_proj.bias
    lowerCAmelCase_  :							List[str]								=					esm_layer.self_attn.k_proj.weight
    lowerCAmelCase_  :							str								=					esm_layer.self_attn.k_proj.bias
    lowerCAmelCase_  :							int								=					esm_layer.self_attn.v_proj.weight
    lowerCAmelCase_  :							List[Any]								=					esm_layer.self_attn.v_proj.bias

    if getattr(esm_layer.self_attn       ,  'rot_emb'       ,  UpperCamelCase_		) is not None:
      # Matt: Although inv_freq is not a trainable weight, it is computed at model init and cached.
      # During the training of ESM-2 the model was converted to float16 precision, which also converts
      # the inv_freq tensor, and the loss of precision remains even if the model is loaded later as float32.
      # If we recompute inv_freq without this loss of precision then we will get subtly different rotary
      # embeddings, which are enough to cause significant discrepancies in model outputs. To avoid this,
      # we make sure the new model copies the data from the old inv_freq.
      lowerCAmelCase_  :							Optional[Any]								=					esm_layer.self_attn.rot_emb.inv_freq

    # LayerNorm changes for pre-activation
    lowerCAmelCase_  :							Dict								=					esm_layer.self_attn_layer_norm.weight
    lowerCAmelCase_  :							List[Any]								=					esm_layer.self_attn_layer_norm.bias
    lowerCAmelCase_  :							Dict								=					esm_layer.final_layer_norm.weight
    lowerCAmelCase_  :							Any								=					esm_layer.final_layer_norm.bias

    # self-attention output
    lowerCAmelCase_  :							List[str]								=					layer.attention.output
    assert self_output.dense.weight.shape == esm_layer.self_attn.out_proj.weight.shape
    lowerCAmelCase_  :							Dict								=					esm_layer.self_attn.out_proj.weight
    lowerCAmelCase_  :							Dict								=					esm_layer.self_attn.out_proj.bias

    # intermediate
    lowerCAmelCase_  :							str								=					layer.intermediate
    assert intermediate.dense.weight.shape == esm_layer.fca.weight.shape
    lowerCAmelCase_  :							Tuple								=					esm_layer.fca.weight
    lowerCAmelCase_  :							Optional[int]								=					esm_layer.fca.bias

    # output
    lowerCAmelCase_  :							Dict								=					layer.output
    assert bert_output.dense.weight.shape == esm_layer.fca.weight.shape
    lowerCAmelCase_  :							List[str]								=					esm_layer.fca.weight
    lowerCAmelCase_  :							Optional[int]								=					esm_layer.fca.bias
    # end of layer

  if is_folding_model:
    lowerCAmelCase_  :							Tuple								=					esm.esm_s_combine.data
    lowerCAmelCase_  :							Union[str, Any]								=					esm.afa_to_esm.data
    transfer_and_check_weights(esm.embedding       ,  model.embedding		)
    transfer_and_check_weights(esm.esm_s_mlp       ,  model.esm_s_mlp		)
    transfer_and_check_weights(esm.trunk       ,  model.trunk		)
    transfer_and_check_weights(esm.distogram_head       ,  model.distogram_head		)
    transfer_and_check_weights(esm.ptm_head       ,  model.ptm_head		)
    transfer_and_check_weights(esm.lm_head       ,  model.lm_head		)
    transfer_and_check_weights(esm.lddt_head       ,  model.lddt_head		)

  elif classification_head:
    lowerCAmelCase_  :							Union[str, Any]								=					esm.esm.classification_heads['mnli'].dense.weight
    lowerCAmelCase_  :							Dict								=					esm.classification_heads['mnli'].dense.bias
    lowerCAmelCase_  :							Any								=					esm.classification_heads['mnli'].out_proj.weight
    lowerCAmelCase_  :							str								=					esm.classification_heads['mnli'].out_proj.bias
  else:
    # LM Head
    lowerCAmelCase_  :							List[str]								=					esm.lm_head.dense.weight
    lowerCAmelCase_  :							str								=					esm.lm_head.dense.bias
    lowerCAmelCase_  :							Dict								=					esm.lm_head.layer_norm.weight
    lowerCAmelCase_  :							Optional[int]								=					esm.lm_head.layer_norm.bias
    lowerCAmelCase_  :							Dict								=					esm.lm_head.weight
    lowerCAmelCase_  :							Any								=					esm.lm_head.bias

  # Contact prediction head
  transfer_and_check_weights(esm.contact_head       ,  model.esm.contact_head		)

  # Prepare data (first 2 sequences from ESMStructuralSplitDataset superfamily / 4)
  if is_folding_model:
    # Folding models aren't trained on masked inputs and don't like mask tokens.
    lowerCAmelCase_  :							Dict								=					SAMPLE_DATA[:2]
  else:
    lowerCAmelCase_  :							Dict								=					SAMPLE_DATA

  if is_folding_model:
    lowerCAmelCase_  :							Any								=					get_esmfold_tokenizer()
    lowerCAmelCase_  :							Tuple								=					hf_tokenizer(
        [row[1] for row in sample_data]       ,  return_tensors='pt'       ,  padding=UpperCamelCase_       ,  add_special_tokens=UpperCamelCase_		)
    lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_  :							List[Any]								=					esmfold_encode_sequences([row[1] for row in sample_data]		)
    lowerCAmelCase_  :							Any								=					torch.all(hf_tokens['input_ids'] == esmfold_aas		) and torch.all(
        hf_tokens['attention_mask'] == esmfold_mask		)
  else:
    # Let's check that we get the same results.
    lowerCAmelCase_  :							Tuple								=					alphabet.get_batch_converter()
    lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_  :							Optional[int]								=					batch_converter(UpperCamelCase_		)
    # Prepare tokenizer and make sure it matches
    with TemporaryDirectory() as tempdir:
      lowerCAmelCase_  :							List[str]								=					'\n'.join(alphabet.all_toks		)
      lowerCAmelCase_  :							str								=					Path(UpperCamelCase_		) / 'vocab.txt'
      vocab_file.write_text(UpperCamelCase_		)
      lowerCAmelCase_  :							List[str]								=					EsmTokenizer(vocab_file=str(UpperCamelCase_		)		)

    lowerCAmelCase_  :							Tuple								=					hf_tokenizer([row[1] for row in sample_data]       ,  return_tensors='pt'       ,  padding=UpperCamelCase_		)
    lowerCAmelCase_  :							Any								=					torch.all(hf_tokens['input_ids'] == batch_tokens		)

  print('Do both models tokenizers output the same tokens?'       ,  '🔥' if success else '💩'		)
  if not success:
    raise Exception('Tokenization does not match!'		)

  with torch.no_grad():
    if is_folding_model:
      # Let's test the model in parts
      # ESMFold always converts the ESM stem to float16, which requires float16 ops
      # that don't exist on CPU. Therefore, to test it we need to run it on GPU. However,
      # ESMFold is what we in the community call a "big boy" and so we desperately avoid putting both the
      # original and the converted model on the GPU at the same time.
      lowerCAmelCase_  :							Optional[Any]								=					esm.cuda().infer([row[1] for row in sample_data]		)
      lowerCAmelCase_  :							Union[str, Any]								=					model.cuda()(
          input_ids=hf_tokens['input_ids'].cuda()       ,  attention_mask=hf_tokens['attention_mask'].cuda()		)
    else:
      lowerCAmelCase_  :							Optional[Any]								=					model(**UpperCamelCase_       ,  output_hidden_states=UpperCamelCase_		)
      lowerCAmelCase_  :							str								=					our_output['logits']
      if classification_head:
        lowerCAmelCase_  :							List[Any]								=					esm.model.classification_heads['mnli'](esm.extract_features(UpperCamelCase_		)		)
      else:
        lowerCAmelCase_  :							Optional[Any]								=					esm(hf_tokens['input_ids']       ,  repr_layers=list(range(999		)		)		)
        lowerCAmelCase_  :							Any								=					their_output['logits']

    if is_folding_model:
      lowerCAmelCase_  :							Dict								=					torch.max(torch.abs(our_output['positions'] - their_output['positions']		)		).item()
      lowerCAmelCase_  :							Dict								=					torch.allclose(our_output['positions']       ,  their_output['positions']       ,  atol=1e-5		)
    else:
      lowerCAmelCase_  :							Optional[Any]								=					torch.max(torch.abs(our_output - their_output		)		).item()
      lowerCAmelCase_  :							int								=					torch.allclose(UpperCamelCase_       ,  UpperCamelCase_       ,  atol=1e-5		)

    print(f"max_absolute_diff = {max_absolute_diff}"		)  # ~ 1e-5
    print('Do both models output the same tensors?'       ,  '🔥' if success else '💩'		)

    if not success:
      raise Exception('Something went wRoNg'		)

    if not is_folding_model:
      # Let's check contact prediction too
      lowerCAmelCase_  :							Union[str, Any]								=					model.predict_contacts(hf_tokens['input_ids']       ,  hf_tokens['attention_mask']		)
      lowerCAmelCase_  :							str								=					esm.predict_contacts(hf_tokens['input_ids']		)
      lowerCAmelCase_  :							Union[str, Any]								=					torch.max(torch.abs(our_output - their_output		)		).item()
      lowerCAmelCase_  :							List[Any]								=					torch.allclose(UpperCamelCase_       ,  UpperCamelCase_       ,  atol=1e-5		)

      print('Contact prediction testing:'		)
      print(f"max_absolute_diff = {max_absolute_diff}"		)  # ~ 1e-5
      print('Do both models output the same tensors?'       ,  '🔥' if success else '💩'		)

      if not success:
        raise Exception('Something went wRoNg'		)

    pathlib.Path(UpperCamelCase_		).mkdir(parents=UpperCamelCase_       ,  exist_ok=UpperCamelCase_		)
    print(f"Saving model to {pytorch_dump_folder_path}"		)
    model.save_pretrained(UpperCamelCase_		)

    del esm  # Free up some memory before continuing

  print(f"Saving tokenizer to {pytorch_dump_folder_path}"		)
  hf_tokenizer.save_pretrained(UpperCamelCase_		)

  if push_to_repo:
    model.push_to_hub(repo_id=UpperCamelCase_       ,  use_auth_token=UpperCamelCase_		)
    hf_tokenizer.push_to_hub(repo_id=UpperCamelCase_       ,  use_auth_token=UpperCamelCase_		)


if __name__ == "__main__":
     lowercase__						:							Dict        =      argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         """--pytorch_dump_folder_path""", type=str, required=True, help="""Path to the output PyTorch model."""
     )
     parser.add_argument(
         """--classification_head""", action="""store_true""", help="""Whether to convert a final classification head."""
     )
     parser.add_argument("""--model""", default=None, type=str, required=True, help="""Name of model to convert.""")
     parser.add_argument("""--push_to_repo""", type=str, help="""Repo to upload to (including username!).""")
     parser.add_argument("""--auth_token""", type=str, help="""HuggingFace auth token.""")
     lowercase__						:							Optional[int]        =      parser.parse_args()
     convert_esm_checkpoint_to_pytorch(
         args.model, args.pytorch_dump_folder_path, args.classification_head, args.push_to_repo, args.auth_token
     )








"""simple docstring"""





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import OwlViTImageProcessor




class    _lowerCAmelCase    (      unittest.TestCase  ):







 """simple docstring"""







 def __init__(     self				:     Union[str, Any],   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Optional[int]=7,   UpperCAmelCase__				:     List[str]=3,   UpperCAmelCase__				:     List[Any]=1_8,   UpperCAmelCase__				:     Any=3_0,   UpperCAmelCase__				:     str=4_0_0,   UpperCAmelCase__				:     Union[str, Any]=True,   UpperCAmelCase__				:     Dict=None,   UpperCAmelCase__				:     int=True,   UpperCAmelCase__				:     str=None,   UpperCAmelCase__				:     Dict=True,   UpperCAmelCase__				:     str=[0.48_145_466, 0.4_578_275, 0.40_821_073],   UpperCAmelCase__				:     Dict=[0.26_862_954, 0.26_130_258, 0.27_577_711],   UpperCAmelCase__				:     Any=True,   ):
    __lowercase								=		parent
    __lowercase								=		batch_size
    __lowercase								=		num_channels
    __lowercase								=		image_size
    __lowercase								=		min_resolution
    __lowercase								=		max_resolution
    __lowercase								=		do_resize
    __lowercase								=		size if size is not None else {"height": 1_8, "width": 1_8}
    __lowercase								=		do_center_crop
    __lowercase								=		crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
    __lowercase								=		do_normalize
    __lowercase								=		image_mean
    __lowercase								=		image_std
    __lowercase								=		do_convert_rgb



 def    _lowercase					(     self				:     List[str]      ):
    return {
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
        "do_normalize": self.do_normalize,
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_convert_rgb": self.do_convert_rgb,
    }







@require_torch
@require_vision
class    _lowerCAmelCase    (      lowercase	,unittest.TestCase  ):







 """simple docstring"""







 __UpperCAmelCase      :   List[str]  						=      OwlViTImageProcessor if is_vision_available() else None


 def    _lowercase					(     self				:     Dict      ):
    __lowercase								=		OwlViTImageProcessingTester(self      )


 @property
 def    _lowercase					(     self				:     int      ):
    return self.image_processor_tester.prepare_image_processor_dict()


 def    _lowercase					(     self				:     Tuple      ):
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_resize"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "size"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_center_crop"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "center_crop"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_normalize"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "image_mean"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "image_std"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_convert_rgb"      )      )


 def    _lowercase					(     self				:     Dict      ):
    __lowercase								=		self.image_processing_class.from_dict(self.image_processor_dict      )
    self.assertEqual(image_processor.size,   {"height": 1_8, "width": 1_8}      )
    self.assertEqual(image_processor.crop_size,   {"height": 1_8, "width": 1_8}      )

    __lowercase								=		self.image_processing_class.from_dict(self.image_processor_dict,   size=4_2,   crop_size=8_4      )
    self.assertEqual(image_processor.size,   {"height": 4_2, "width": 4_2}      )
    self.assertEqual(image_processor.crop_size,   {"height": 8_4, "width": 8_4}      )


 def    _lowercase					(     self				:     Any      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random PIL images
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__      )

    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   Image.Image      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )


 def    _lowercase					(     self				:     Optional[Any]      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random numpy tensors
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__,   numpify=UpperCAmelCase__      )
    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   np.ndarray      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )



 def    _lowercase					(     self				:     List[str]      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random PyTorch tensors
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__,   torchify=UpperCAmelCase__      )
    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   torch.Tensor      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )




