
# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


snake_case :		Any							      =  get_logger(__name__)





class       _snake_case					:
			UpperCamelCase__          =    'dummy_data'
			UpperCamelCase__          =    'datasets'
			UpperCamelCase__          =    False







			def __init__(				self						,   _a						,   _a						,   _a						,   _a = None						,   _a = False						,   _a = True						,   _a = None						,   ):
				__magic_name__		:		Optional[Any]	   =     0
				__magic_name__		:		str	   =     dataset_name
				__magic_name__		:		List[Any]	   =     cache_dir
				__magic_name__		:		Optional[int]	   =     use_local_dummy_data
				__magic_name__		:		Union[str, Any]	   =     config
				# download_callbacks take a single url as input
				__magic_name__		:		List[Callable]	   =     download_callbacks or []
				# if False, it doesn't load existing files and it returns the paths of the dummy files relative
				# to the dummy_data zip file root
				__magic_name__		:		str	   =     load_existing_dummy_data

				# TODO(PVP, QL) might need to make this more general
				__magic_name__		:		Optional[int]	   =     str(_a		)
				# to be downloaded
				__magic_name__		:		int	   =     None
				__magic_name__		:		List[Any]	   =     None







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				if self._dummy_file is None:
					__magic_name__		:		int	   =     self.download_dummy_data()
				return self._dummy_file







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				if self.config is not None:
					# structure is dummy / config_name / version_name
					return os.path.join("dummy"						,   self.config.name						,   self.version_name		)
				# structure is dummy / version_name
				return os.path.join("dummy"						,   self.version_name		)







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				return os.path.join(self.dummy_data_folder						,   "dummy_data.zip"		)







			def 			SCREAMING_SNAKE_CASE    (				self		):
				__magic_name__		:		Dict	   =     (
				    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
				)

				__magic_name__		:		List[str]	   =     cached_path(
				    _a						,   cache_dir=self.cache_dir						,   extract_compressed_file=_a						,   force_extract=_a		)

				return os.path.join(_a						,   self.dummy_file_name		)







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				return os.path.join(self.datasets_scripts_dir						,   self.dataset_name						,   self.dummy_zip_file		)







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				if self._bucket_url is None:
					__magic_name__		:		str	   =     hf_github_url(self.dataset_name						,   self.dummy_zip_file.replace(os.sep						,   "/"		)		)
				return self._bucket_url







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				# return full path if its a dir
				if os.path.isdir(self.dummy_file		):
					return self.dummy_file
				# else cut off path to file -> example `xsum`.
				return "/".join(self.dummy_file.replace(os.sep						,   "/"		).split("/"		)[:-1]		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   *_a		):
				if self.load_existing_dummy_data:
					# dummy data is downloaded and tested
					__magic_name__		:		Optional[Any]	   =     self.dummy_file
				else:
					# dummy data cannot be downloaded and only the path to dummy file is returned
					__magic_name__		:		Any	   =     self.dummy_file_name

				# special case when data_url is a dict
				if isinstance(_a						,   _a		):
					return self.create_dummy_data_dict(_a						,   _a		)
				elif isinstance(_a						,   (list, tuple)		):
					return self.create_dummy_data_list(_a						,   _a		)
				else:
					return self.create_dummy_data_single(_a						,   _a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   *_a		):
				return self.download_and_extract(_a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				return self.download_and_extract(_a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   *_a						,   **_a		):
				return path







			def 			SCREAMING_SNAKE_CASE    (				self		):
				return {}







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				__magic_name__		:		str	   =     {}
				for key, single_urls in data_url.items():
					for download_callback in self.download_callbacks:
						if isinstance(_a						,   _a		):
							for single_url in single_urls:
								download_callback(_a		)
						else:
							__magic_name__		:		List[str]	   =     single_urls
							download_callback(_a		)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
					if isinstance(_a						,   _a		):
						__magic_name__		:		Dict	   =     [os.path.join(_a						,   urllib.parse.quote_plus(Path(_a		).name		)		) for x in single_urls]
					else:
						__magic_name__		:		str	   =     single_urls
						__magic_name__		:		List[str]	   =     os.path.join(_a						,   urllib.parse.quote_plus(Path(_a		).name		)		)
					__magic_name__		:		Optional[int]	   =     value

				# make sure that values are unique
				if all(isinstance(_a						,   _a		) for i in dummy_data_dict.values()		) and len(set(dummy_data_dict.values()		)		) < len(
				    dummy_data_dict.values()		):
					# append key to value to make its name unique
					__magic_name__		:		int	   =     {key: value + key for key, value in dummy_data_dict.items()}

				return dummy_data_dict







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				__magic_name__		:		Union[str, Any]	   =     []
				# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
				__magic_name__		:		Tuple	   =     all(bool(re.findall("[0-9]{3,}-of-[0-9]{3,}"						,   _a		)		) for url in data_url		)
				__magic_name__		:		List[str]	   =     all(
				    url.startswith("https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed"		) for url in data_url		)
				if data_url and (is_tf_records or is_pubmed_records):
					__magic_name__		:		List[str]	   =     [data_url[0]] * len(_a		)
				for single_url in data_url:
					for download_callback in self.download_callbacks:
						download_callback(_a		)
					# we force the name of each key to be the last file / folder name of the url path
					# if the url has arguments, we need to encode them with urllib.parse.quote_plus
					__magic_name__		:		Optional[int]	   =     os.path.join(_a						,   urllib.parse.quote_plus(single_url.split("/"		)[-1]		)		)
					dummy_data_list.append(_a		)
				return dummy_data_list







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				for download_callback in self.download_callbacks:
					download_callback(_a		)
				# we force the name of each key to be the last file / folder name of the url path
				# if the url has arguments, we need to encode them with urllib.parse.quote_plus
				__magic_name__		:		List[Any]	   =     os.path.join(_a						,   urllib.parse.quote_plus(data_url.split("/"		)[-1]		)		)
				if os.path.exists(_a		) or not self.load_existing_dummy_data:
					return value
				else:
					# Backward compatibility, maybe deprecate at one point.
					# For many datasets with single url calls to dl_manager.download_and_extract,
					# the dummy_data.zip file is actually the zipped downloaded file
					# while now we expected the dummy_data.zip file to be a directory containing
					# the downloaded file.
					return path_to_dummy_data







			def 			SCREAMING_SNAKE_CASE    (				self		):
				pass







			def 			SCREAMING_SNAKE_CASE    (				self		):
				pass







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				def _iter_archive_members(_a		):
					# this preserves the order of the members inside the ZIP archive
					__magic_name__		:		Optional[Any]	   =     Path(self.dummy_file		).parent
					__magic_name__		:		List[str]	   =     path.relative_to(_a		)
					with ZipFile(self.local_path_to_dummy_data		) as zip_file:
						__magic_name__		:		List[Any]	   =     zip_file.namelist()
					for member in members:
						if member.startswith(relative_path.as_posix()		):
							yield dummy_parent_path.joinpath(_a		)

				__magic_name__		:		Dict	   =     Path(_a		)
				__magic_name__		:		int	   =     _iter_archive_members(_a		) if self.use_local_dummy_data else path.rglob("*"		)
				for file_path in file_paths:
					if file_path.is_file() and not file_path.name.startswith((".", "__")		):
						yield file_path.relative_to(_a		).as_posix(), file_path.open("rb"		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				if not isinstance(_a						,   _a		):
					__magic_name__		:		Dict	   =     [paths]
				for path in paths:
					if os.path.isfile(_a		):
						if os.path.basename(_a		).startswith((".", "__")		):
							return
						yield path
					else:
						for dirpath, dirnames, filenames in os.walk(_a		):
							if os.path.basename(_a		).startswith((".", "__")		):
								continue
							dirnames.sort()
							for filename in sorted(_a		):
								if filename.startswith((".", "__")		):
									continue
								yield os.path.join(_a						,   _a		)


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_						(					)				->		str:







	'''simple docstring'''


	__magic_name__		:		int	   =     "https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"
	__magic_name__		:		Union[str, Any]	   =     Image.open(requests.get(_snake_case      ,   stream=_snake_case   ).raw   ).convert("RGB"   )

	return image






def   lowerCAmelCase_						(					_snake_case      :  str   )				->		Union[str, Any]:







	'''simple docstring'''


	__magic_name__		:		List[str]	   =     []
	# 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_						(					_snake_case      :  Any      ,   _snake_case      :  Union[str, Any]      ,   _snake_case      :  Optional[Any]   )				->		int:







	'''simple docstring'''


	__magic_name__		:		Tuple	   =     dct.pop(_snake_case   )
	__magic_name__		:		int	   =     val






def   lowerCAmelCase_						(					_snake_case      :  List[str]      ,   _snake_case      :  Optional[Any]   )				->		Dict:







	'''simple docstring'''


	for i in range(config.vision_config.num_hidden_layers   ):
		# read in original q and v biases
		__magic_name__		:		List[Any]	   =     state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''   )
		__magic_name__		:		Optional[Any]	   =     state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''   )

		# next, set bias in the state dict
		__magic_name__		:		Optional[int]	   =     torch.cat((q_bias, torch.zeros_like(_snake_case      ,   requires_grad=_snake_case   ), v_bias)   )
		__magic_name__		:		Union[str, Any]	   =     qkv_bias






def   lowerCAmelCase_						(					_snake_case      :  Dict      ,   _snake_case      :  str   )				->		int:







	'''simple docstring'''


	__magic_name__		:		List[Any]	   =     364 if "coco" in model_name else 224
	__magic_name__		:		Union[str, Any]	   =     BlipaVisionConfig(image_size=_snake_case   ).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:
		__magic_name__		:		List[str]	   =     OPTConfig.from_pretrained("facebook/opt-2.7b"      ,   eos_token_id=_snake_case   ).to_dict()
	elif "opt-6.7b" in model_name:
		__magic_name__		:		Any	   =     OPTConfig.from_pretrained("facebook/opt-6.7b"      ,   eos_token_id=_snake_case   ).to_dict()
	elif "t5-xl" in model_name:
		__magic_name__		:		Dict	   =     TaConfig.from_pretrained("google/flan-t5-xl"      ,   dense_act_fn="gelu"      ,   bos_token_id=1   ).to_dict()
	elif "t5-xxl" in model_name:
		__magic_name__		:		int	   =     TaConfig.from_pretrained("google/flan-t5-xxl"      ,   dense_act_fn="gelu"      ,   bos_token_id=1   ).to_dict()

	__magic_name__		:		List[Any]	   =     BlipaConfig(vision_config=_snake_case      ,   text_config=_snake_case   )

	return config, image_size






@torch.no_grad()
def   lowerCAmelCase_						(					_snake_case      :  List[str]      ,   _snake_case      :  str=None      ,   _snake_case      :  Dict=False   )				->		List[Any]:







	'''simple docstring'''


	__magic_name__		:		Optional[int]	   =     (
	    AutoTokenizer.from_pretrained("facebook/opt-2.7b"   )
	    if "opt" in model_name
	    else AutoTokenizer.from_pretrained("google/flan-t5-xl"   )
	)
	__magic_name__		:		List[Any]	   =     tokenizer("\n"      ,   add_special_tokens=_snake_case   ).input_ids[0]
	__magic_name__   ,    __magic_name__		:		Tuple	   =     get_blipa_config(_snake_case      ,   eos_token_id=_snake_case   )

	__magic_name__		:		Union[str, Any]	   =     BlipaForConditionalGeneration(_snake_case   ).eval()

	__magic_name__		:		Any	   =     {
	    "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"),
	}

	__magic_name__   ,    __magic_name__		:		Union[str, Any]	   =     model_name_to_original[model_name]

	# load original model
	print("Loading original model..."   )
	__magic_name__		:		Union[str, Any]	   =     "cuda" if torch.cuda.is_available() else "cpu"
	__magic_name__   ,    __magic_name__   ,    __magic_name__		:		Optional[Any]	   =     load_model_and_preprocess(
	    name=_snake_case      ,   model_type=_snake_case      ,   is_eval=_snake_case      ,   device=_snake_case   )
	original_model.eval()
	print("Done!"   )

	# update state dict keys
	__magic_name__		:		Dict	   =     original_model.state_dict()
	__magic_name__		:		str	   =     create_rename_keys(_snake_case   )
	for src, dest in rename_keys:
		rename_key(_snake_case      ,   _snake_case      ,   _snake_case   )

	# some keys can be renamed efficiently
	for key, val in state_dict.copy().items():
		__magic_name__		:		Any	   =     state_dict.pop(_snake_case   )
		if key.startswith("Qformer.bert"   ):
			__magic_name__		:		Optional[int]	   =     key.replace("Qformer.bert"      ,   "qformer"   )
		if "attention.self" in key:
			__magic_name__		:		Any	   =     key.replace("self"      ,   "attention"   )
		if "opt_proj" in key:
			__magic_name__		:		Union[str, Any]	   =     key.replace("opt_proj"      ,   "language_projection"   )
		if "t5_proj" in key:
			__magic_name__		:		Optional[int]	   =     key.replace("t5_proj"      ,   "language_projection"   )
		if key.startswith("opt"   ):
			__magic_name__		:		List[str]	   =     key.replace("opt"      ,   "language"   )
		if key.startswith("t5"   ):
			__magic_name__		:		Tuple	   =     key.replace("t5"      ,   "language"   )
		__magic_name__		:		Dict	   =     val

	# read in qv biases
	read_in_q_v_bias(_snake_case      ,   _snake_case   )

	__magic_name__   ,    __magic_name__		:		Tuple	   =     hf_model.load_state_dict(_snake_case      ,   strict=_snake_case   )
	assert len(_snake_case   ) == 0
	assert unexpected_keys == ["qformer.embeddings.position_ids"]

	__magic_name__		:		List[Any]	   =     load_demo_image()
	__magic_name__		:		Tuple	   =     vis_processors["eval"](_snake_case   ).unsqueeze(0   ).to(_snake_case   )
	__magic_name__		:		Dict	   =     tokenizer(["\n"]      ,   return_tensors="pt"   ).input_ids.to(_snake_case   )

	# create processor
	__magic_name__		:		Optional[Any]	   =     BlipImageProcessor(
	    size={"height": image_size, "width": image_size}      ,   image_mean=_snake_case      ,   image_std=_snake_case   )
	__magic_name__		:		Dict	   =     BlipaProcessor(image_processor=_snake_case      ,   tokenizer=_snake_case   )
	__magic_name__		:		Union[str, Any]	   =     processor(images=_snake_case      ,   return_tensors="pt"   ).pixel_values.to(_snake_case   )

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

	original_model.to(_snake_case   )
	hf_model.to(_snake_case   )
	with torch.no_grad():
		if "opt" in model_name:
			__magic_name__		:		List[Any]	   =     original_model({"image": original_pixel_values, "text_input": [""]}   ).logits
			__magic_name__		:		Optional[int]	   =     hf_model(_snake_case      ,   _snake_case   ).logits
		else:
			__magic_name__		:		int	   =     original_model(
			    {"image": original_pixel_values, "text_input": ["\n"], "text_output": ["\n"]}   ).logits
			__magic_name__		:		Tuple	   =     input_ids.masked_fill(input_ids == tokenizer.pad_token_id      ,   -100   )
			__magic_name__		:		List[str]	   =     hf_model(_snake_case      ,   _snake_case      ,   labels=_snake_case   ).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":
		__magic_name__		:		List[str]	   =     torch.tensor(
		    [[-41.5_850, -4.4_440, -8.9_922], [-47.4_322, -5.9_143, -1.7_340]]      ,   device=_snake_case   )
		assert torch.allclose(logits[0, :3, :3]      ,   _snake_case      ,   atol=1E-4   )
	elif model_name == "blip2-flan-t5-xl-coco":
		__magic_name__		:		Tuple	   =     torch.tensor(
		    [[-57.0_109, -9.8_967, -12.6_280], [-68.6_578, -12.7_191, -10.5_065]]      ,   device=_snake_case   )
	else:
		# cast to same type
		__magic_name__		:		str	   =     logits.dtype
		assert torch.allclose(original_logits.to(_snake_case   )      ,   _snake_case      ,   atol=1E-2   )
	print("Looks ok!"   )

	print("Generating a caption..."   )
	__magic_name__		:		Optional[int]	   =     ""
	__magic_name__		:		Dict	   =     tokenizer(_snake_case      ,   return_tensors="pt"   ).input_ids.to(_snake_case   )

	__magic_name__		:		int	   =     original_model.generate({"image": original_pixel_values}   )
	__magic_name__		:		Optional[Any]	   =     hf_model.generate(
	    _snake_case      ,   _snake_case      ,   do_sample=_snake_case      ,   num_beams=5      ,   max_length=30      ,   min_length=1      ,   top_p=0.9      ,   repetition_penalty=1.0      ,   length_penalty=1.0      ,   temperature=1      ,   )
	print("Original generation:"      ,   _snake_case   )
	__magic_name__		:		Tuple	   =     input_ids.shape[1]
	__magic_name__		:		int	   =     processor.batch_decode(outputs[:, prompt_length:]      ,   skip_special_tokens=_snake_case   )
	__magic_name__		:		Union[str, Any]	   =     [text.strip() for text in output_text]
	print("HF generation:"      ,   _snake_case   )

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

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


if __name__ == "__main__":
				snake_case :		Any							      =  argparse.ArgumentParser()
				snake_case :		Union[str, Any]							      =  [
				    "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",
				)

				snake_case :		int							      =  parser.parse_args()

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