






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def      lowercase__      (     __snake_case    :							Namespace  ):


					'''simple docstring'''


					return ConvertCommand(
					    args.model_type     ,       args.tf_checkpoint     ,       args.pytorch_dump_output     ,       args.config     ,       args.finetuning_task_name  )


__UpperCAmelCase								=						'\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n'






class   lowerCamelCase      (_snake_case			):







		'''simple docstring'''



		@staticmethod
		def 					__UpperCAmelCase			(							_UpperCamelCase   )	->							Tuple:
							UpperCAmelCase_    :      Optional[Any]            =						parser.add_parser(
							    'convert'				,		help='CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.'				,		)
							train_parser.add_argument('--model_type'				,		type=_UpperCamelCase				,		required=_UpperCamelCase				,		help='Model\'s type.'   )
							train_parser.add_argument(
							    '--tf_checkpoint'				,		type=_UpperCamelCase				,		required=_UpperCamelCase				,		help='TensorFlow checkpoint path or folder.'   )
							train_parser.add_argument(
							    '--pytorch_dump_output'				,		type=_UpperCamelCase				,		required=_UpperCamelCase				,		help='Path to the PyTorch saved model output.'   )
							train_parser.add_argument('--config'				,		type=_UpperCamelCase				,		default=''				,		help='Configuration file path or folder.'   )
							train_parser.add_argument(
							    '--finetuning_task_name'				,		type=_UpperCamelCase				,		default=_UpperCamelCase				,		help='Optional fine-tuning task name if the TF model was a finetuned model.'				,		)
							train_parser.set_defaults(func=_UpperCamelCase   )



		def __init__(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		*_UpperCamelCase				,		)	->							Union[str, Any]:
							UpperCAmelCase_    :      Dict            =						logging.get_logger('transformers-cli/converting'   )

							self._logger.info(f"Loading model {model_type}"   )
							UpperCAmelCase_    :      Dict            =						model_type
							UpperCAmelCase_    :      Optional[int]            =						tf_checkpoint
							UpperCAmelCase_    :      Tuple            =						pytorch_dump_output
							UpperCAmelCase_    :      int            =						config
							UpperCAmelCase_    :      Optional[int]            =						finetuning_task_name



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							if self._model_type == "albert":
												try:
																	from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
																	    convert_tf_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_tf_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "bert":
												try:
																	from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
																	    convert_tf_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_tf_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "funnel":
												try:
																	from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
																	    convert_tf_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_tf_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "t5":
												try:
																	from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_tf_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "gpt":
												from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
												    convert_openai_checkpoint_to_pytorch,
												)

												convert_openai_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "transfo_xl":
												try:
																	from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
																	    convert_transfo_xl_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												if "ckpt" in self._tf_checkpoint.lower():
																	UpperCAmelCase_    :      Union[str, Any]            =						self._tf_checkpoint
																	UpperCAmelCase_    :      Tuple            =						''
												else:
																	UpperCAmelCase_    :      List[Any]            =						self._tf_checkpoint
																	UpperCAmelCase_    :      str            =						''
												convert_transfo_xl_checkpoint_to_pytorch(
												    _UpperCamelCase				,		self._config				,		self._pytorch_dump_output				,		_UpperCamelCase   )
							elif self._model_type == "gpt2":
												try:
																	from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
																	    convert_gpta_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							elif self._model_type == "xlnet":
												try:
																	from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
																	    convert_xlnet_checkpoint_to_pytorch,
																	)
												except ImportError:
																	raise ImportError(_UpperCamelCase   )

												convert_xlnet_checkpoint_to_pytorch(
												    self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output				,		self._finetuning_task_name   )
							elif self._model_type == "xlm":
												from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
												    convert_xlm_checkpoint_to_pytorch,
												)

												convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint				,		self._pytorch_dump_output   )
							elif self._model_type == "lxmert":
												from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
												    convert_lxmert_checkpoint_to_pytorch,
												)

												convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint				,		self._pytorch_dump_output   )
							elif self._model_type == "rembert":
												from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
												    convert_rembert_tf_checkpoint_to_pytorch,
												)

												convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint				,		self._config				,		self._pytorch_dump_output   )
							else:
												raise ValueError(
												    '--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]'   )














import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class   lowerCamelCase      (_snake_case ,  _snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Union[str, Any]       						=  IFImgaImgSuperResolutionPipeline
		_snake_case    :    Union[str, Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
		_snake_case    :    List[Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}			)
		_snake_case    :    List[str]       						=  PipelineTesterMixin.required_optional_params - {'''latents'''}



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							return self._get_superresolution_dummy_components()



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase=0   )	->							Any:
							if str(_UpperCamelCase   ).startswith('mps'   ):
												UpperCAmelCase_    :      List[Any]            =						torch.manual_seed(_UpperCamelCase   )
							else:
												UpperCAmelCase_    :      int            =						torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )

							UpperCAmelCase_    :      List[Any]            =						floats_tensor((1, 3, 3_2, 3_2)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
							UpperCAmelCase_    :      Dict            =						floats_tensor((1, 3, 1_6, 1_6)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

							UpperCAmelCase_    :      Tuple            =						{
							    'prompt': 'A painting of a squirrel eating a burger',
							    'image': image,
							    'original_image': original_image,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'output_type': 'numpy',
							}

							return inputs



		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()				,		reason='XFormers attention is only available with CUDA and `xformers` installed'				,		)
		def 					__UpperCAmelCase			(							self   )	->							Any:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_save_load_optional_components()



		@unittest.skipIf(torch_device != 'cuda'				,		reason='float16 requires CUDA'   )
		def 					__UpperCAmelCase			(							self   )	->							str:
							# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
							super().test_save_load_floataa(expected_max_diff=1E-1   )



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							self._test_save_load_local()



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2				,		)






