


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       __magic_name__	(     snake_case__					,				snake_case__					,				unittest.TestCase):
     A:		int			=      IFImgaImgSuperResolutionPipeline
     A:		Union[str, Any]			=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
     A:		int			=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"})
     A:		Union[str, Any]			=      PipelineTesterMixin.required_optional_params - {"latents"}


     def      UpperCAmelCase__	(      self							:     List[str]			)  ->      Optional[Any]:





      '''simple docstring'''






      return self._get_superresolution_dummy_components()


     def      UpperCAmelCase__	(      self							:     Optional[int]							,	lowerCamelCase__							:     Optional[int]							,	lowerCamelCase__							:     Any=0			)  ->      int:





      '''simple docstring'''






      if str(_SCREAMING_SNAKE_CASE			).startswith('''mps'''			):
       UpperCamelCase__					:    Tuple          =   torch.manual_seed(_SCREAMING_SNAKE_CASE			)
      else:
       UpperCamelCase__					:    List[Any]          =   torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(_SCREAMING_SNAKE_CASE			)

      UpperCamelCase__					:    Any          =   floats_tensor((1, 3, 32, 32)							,	rng=random.Random(_SCREAMING_SNAKE_CASE			)			).to(_SCREAMING_SNAKE_CASE			)
      UpperCamelCase__					:    List[Any]          =   floats_tensor((1, 3, 16, 16)							,	rng=random.Random(_SCREAMING_SNAKE_CASE			)			).to(_SCREAMING_SNAKE_CASE			)

      UpperCamelCase__					:    str          =   {
          '''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							:     List[Any]			)  ->      Optional[int]:





      '''simple docstring'''






      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3			)


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      List[Any]:





      '''simple docstring'''






      self._test_save_load_optional_components()


     @unittest.skipIf(torch_device != '''cuda'''							,	reason='''float16 requires CUDA'''			)
     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      Tuple:





      '''simple docstring'''






      super().test_save_load_floataa(expected_max_diff=1E-1			)


     def      UpperCAmelCase__	(      self							:     Dict			)  ->      str:





      '''simple docstring'''






      self._test_attention_slicing_forward_pass(expected_max_diff=1E-2			)


     def      UpperCAmelCase__	(      self							:     Optional[Any]			)  ->      List[Any]:





      '''simple docstring'''






      self._test_save_load_local()


     def      UpperCAmelCase__	(      self							:     str			)  ->      List[str]:





      '''simple docstring'''






      self._test_inference_batch_single_identical(
          expected_max_diff=1E-2							,	)










from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def 			_a  (				SCREAMING_SNAKE_CASE	:				Namespace     ):







 """simple docstring"""



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


__UpperCamelCase       :       List[Any]						       =				"\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       __magic_name__	(     __lowerCAmelCase):


     @staticmethod
     def      UpperCAmelCase__	(      lowerCamelCase__							:     ArgumentParser			)  ->      Optional[int]:





      '''simple docstring'''






      UpperCamelCase__					:    int          =   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=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''Model\'s type.'''			)
      train_parser.add_argument(
          '''--tf_checkpoint'''							,	type=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''TensorFlow checkpoint path or folder.'''			)
      train_parser.add_argument(
          '''--pytorch_dump_output'''							,	type=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''Path to the PyTorch saved model output.'''			)
      train_parser.add_argument('''--config'''							,	type=lowerCamelCase__							,	default=''''''							,	help='''Configuration file path or folder.'''			)
      train_parser.add_argument(
          '''--finetuning_task_name'''							,	type=lowerCamelCase__							,	default=lowerCamelCase__							,	help='''Optional fine-tuning task name if the TF model was a finetuned model.'''							,	)
      train_parser.set_defaults(func=lowerCamelCase__			)


     def __init__(      self							:     Optional[Any]							,	lowerCamelCase__							:     str							,	lowerCamelCase__							:     str							,	lowerCamelCase__							:     str							,	lowerCamelCase__							:     str							,	lowerCamelCase__							:     str							,	*lowerCamelCase__							:     Optional[int]							,	)  ->      List[Any]:





      '''simple docstring'''






      UpperCamelCase__					:    List[Any]          =   logging.get_logger('''transformers-cli/converting'''			)

      self._logger.info(F"Loading model {model_type}"			)
      UpperCamelCase__					:    List[str]          =   model_type
      UpperCamelCase__					:    Optional[int]          =   tf_checkpoint
      UpperCamelCase__					:    List[Any]          =   pytorch_dump_output
      UpperCamelCase__					:    List[Any]          =   config
      UpperCamelCase__					:    Any          =   finetuning_task_name


     def      UpperCAmelCase__	(      self							:     Optional[Any]			)  ->      Optional[Any]:





      '''simple docstring'''






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

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

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

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

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

       if "ckpt" in self._tf_checkpoint.lower():
        UpperCamelCase__					:    str          =   self._tf_checkpoint
        UpperCamelCase__					:    List[Any]          =   ''''''
       else:
        UpperCamelCase__					:    Any          =   self._tf_checkpoint
        UpperCamelCase__					:    List[Any]          =   ''''''
       convert_transfo_xl_checkpoint_to_pytorch(
           lowerCamelCase__							,	self._config							,	self._pytorch_dump_output							,	lowerCamelCase__			)
      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(lowerCamelCase__			)

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

       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]'''			)


