


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand


def        _UpperCamelCase							(      lowercase__      ):
						return ConvertCommand(
						    args.model_type    ,       args.tf_checkpoint    ,       args.pytorch_dump_output    ,       args.config    ,       args.finetuning_task_name      )


__lowerCAmelCase	: Optional[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        _lowercase      (			A__       ):






				'''simple docstring'''



				@staticmethod
				def 		__magic_name__(       lowerCAmelCase__			:ArgumentParser	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     List[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=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			:int			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:str			,			*lowerCAmelCase__			:List[Any]			,			)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     str					=		logging.get_logger('''transformers-cli/converting'''	)

										self._logger.info(f'''Loading model {model_type}'''	)
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		model_type
										__SCREAMING_SNAKE_CASE						:     str					=		tf_checkpoint
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		pytorch_dump_output
										__SCREAMING_SNAKE_CASE						:     str					=		config
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		finetuning_task_name



				def 		__magic_name__(       self			:int	)		->			List[str]:
										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():
																						__SCREAMING_SNAKE_CASE						:     Dict					=		self._tf_checkpoint
																						__SCREAMING_SNAKE_CASE						:     int					=		''''''
																else:
																						__SCREAMING_SNAKE_CASE						:     int					=		self._tf_checkpoint
																						__SCREAMING_SNAKE_CASE						:     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]'''	)




"""simple docstring"""






import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:





							class      lowerCamelCase__   :







												"""simple docstring"""


												@staticmethod
												def lowerCamelCase__							(       *UpperCamelCase    : List[str] ,       **UpperCamelCase    : Any  ):
																			'''simple docstring'''






																			pass





@is_pipeline_test
@require_vision
@require_torch
class      lowerCamelCase__   (     unittest.TestCase				):







					"""simple docstring"""


					__a	       =							MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






					def lowerCamelCase__							(       self    : List[str] ,       UpperCamelCase    : Tuple ,       UpperCamelCase    : Optional[int] ,       UpperCamelCase    : Tuple  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Optional[int]      							=					pipeline(
												    """zero-shot-object-detection""" ,       model="""hf-internal-testing/tiny-random-owlvit-object-detection"""  )

												__UpperCAmelCase   :						Tuple      							=					[
												    {
												        """image""": """./tests/fixtures/tests_samples/COCO/000000039769.png""",
												        """candidate_labels""": ["""cat""", """remote""", """couch"""],
												    }
												]
												return object_detector, examples






					def lowerCamelCase__							(       self    : int ,       UpperCamelCase    : Optional[int] ,       UpperCamelCase    : List[Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Union[str, Any]      							=					object_detector(examples[0] ,       threshold=0.0  )

												__UpperCAmelCase   :						Tuple      							=					len(UpperCamelCase  )
												self.assertGreater(UpperCamelCase ,       0  )
												self.assertEqual(
												    UpperCamelCase ,       [
												        {
												            """score""": ANY(UpperCamelCase  ),
												            """label""": ANY(UpperCamelCase  ),
												            """box""": {"""xmin""": ANY(UpperCamelCase  ), """ymin""": ANY(UpperCamelCase  ), """xmax""": ANY(UpperCamelCase  ), """ymax""": ANY(UpperCamelCase  )},
												        }
												        for i in range(UpperCamelCase  )
												    ] ,       )






					@require_tf
					@unittest.skip("""Zero Shot Object Detection not implemented in TF"""  )
					def lowerCamelCase__							(       self    : Optional[int]  ):
												'''simple docstring'''






												pass






					@require_torch
					def lowerCamelCase__							(       self    : Union[str, Any]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Tuple      							=					pipeline(
												    """zero-shot-object-detection""" ,       model="""hf-internal-testing/tiny-random-owlvit-object-detection"""  )

												__UpperCAmelCase   :						Tuple      							=					object_detector(
												    """./tests/fixtures/tests_samples/COCO/000000039769.png""" ,       candidate_labels=["""cat""", """remote""", """couch"""] ,       threshold=0.64 ,       )

												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        {"""score""": 0.7235, """label""": """cat""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												        {"""score""": 0.7218, """label""": """remote""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												        {"""score""": 0.7184, """label""": """couch""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												        {"""score""": 0.6748, """label""": """remote""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												        {"""score""": 0.6656, """label""": """cat""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												        {"""score""": 0.6614, """label""": """couch""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												        {"""score""": 0.6456, """label""": """remote""", """box""": {"""xmin""": 494, """ymin""": 105, """xmax""": 521, """ymax""": 127}},
												        {"""score""": 0.642, """label""": """remote""", """box""": {"""xmin""": 67, """ymin""": 274, """xmax""": 93, """ymax""": 297}},
												        {"""score""": 0.6419, """label""": """cat""", """box""": {"""xmin""": 494, """ymin""": 105, """xmax""": 521, """ymax""": 127}},
												    ] ,       )

												__UpperCAmelCase   :						Any      							=					object_detector(
												    [
												        {
												            """image""": """./tests/fixtures/tests_samples/COCO/000000039769.png""",
												            """candidate_labels""": ["""cat""", """remote""", """couch"""],
												        }
												    ] ,       threshold=0.64 ,       )

												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        [
												            {"""score""": 0.7235, """label""": """cat""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												            {"""score""": 0.7218, """label""": """remote""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												            {"""score""": 0.7184, """label""": """couch""", """box""": {"""xmin""": 204, """ymin""": 167, """xmax""": 232, """ymax""": 190}},
												            {"""score""": 0.6748, """label""": """remote""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												            {"""score""": 0.6656, """label""": """cat""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												            {"""score""": 0.6614, """label""": """couch""", """box""": {"""xmin""": 571, """ymin""": 83, """xmax""": 598, """ymax""": 103}},
												            {"""score""": 0.6456, """label""": """remote""", """box""": {"""xmin""": 494, """ymin""": 105, """xmax""": 521, """ymax""": 127}},
												            {"""score""": 0.642, """label""": """remote""", """box""": {"""xmin""": 67, """ymin""": 274, """xmax""": 93, """ymax""": 297}},
												            {"""score""": 0.6419, """label""": """cat""", """box""": {"""xmin""": 494, """ymin""": 105, """xmax""": 521, """ymax""": 127}},
												        ]
												    ] ,       )






					@require_torch
					@slow
					def lowerCamelCase__							(       self    : Optional[int]  ):
												'''simple docstring'''






												__UpperCAmelCase   :						Any      							=					pipeline("""zero-shot-object-detection"""  )

												__UpperCAmelCase   :						int      							=					object_detector(
												    """http://images.cocodataset.org/val2017/000000039769.jpg""" ,       candidate_labels=["""cat""", """remote""", """couch"""] ,       )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        {"""score""": 0.2868, """label""": """cat""", """box""": {"""xmin""": 324, """ymin""": 20, """xmax""": 640, """ymax""": 373}},
												        {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 72, """xmax""": 177, """ymax""": 115}},
												        {"""score""": 0.2537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 55, """xmax""": 315, """ymax""": 472}},
												        {"""score""": 0.1474, """label""": """remote""", """box""": {"""xmin""": 335, """ymin""": 74, """xmax""": 371, """ymax""": 187}},
												        {"""score""": 0.1208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 642, """ymax""": 476}},
												    ] ,       )

												__UpperCAmelCase   :						List[str]      							=					object_detector(
												    [
												        {
												            """image""": """http://images.cocodataset.org/val2017/000000039769.jpg""",
												            """candidate_labels""": ["""cat""", """remote""", """couch"""],
												        },
												        {
												            """image""": """http://images.cocodataset.org/val2017/000000039769.jpg""",
												            """candidate_labels""": ["""cat""", """remote""", """couch"""],
												        },
												    ] ,       )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        [
												            {"""score""": 0.2868, """label""": """cat""", """box""": {"""xmin""": 324, """ymin""": 20, """xmax""": 640, """ymax""": 373}},
												            {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 72, """xmax""": 177, """ymax""": 115}},
												            {"""score""": 0.2537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 55, """xmax""": 315, """ymax""": 472}},
												            {"""score""": 0.1474, """label""": """remote""", """box""": {"""xmin""": 335, """ymin""": 74, """xmax""": 371, """ymax""": 187}},
												            {"""score""": 0.1208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 642, """ymax""": 476}},
												        ],
												        [
												            {"""score""": 0.2868, """label""": """cat""", """box""": {"""xmin""": 324, """ymin""": 20, """xmax""": 640, """ymax""": 373}},
												            {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 72, """xmax""": 177, """ymax""": 115}},
												            {"""score""": 0.2537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 55, """xmax""": 315, """ymax""": 472}},
												            {"""score""": 0.1474, """label""": """remote""", """box""": {"""xmin""": 335, """ymin""": 74, """xmax""": 371, """ymax""": 187}},
												            {"""score""": 0.1208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 642, """ymax""": 476}},
												        ],
												    ] ,       )






					@require_tf
					@unittest.skip("""Zero Shot Object Detection not implemented in TF"""  )
					def lowerCamelCase__							(       self    : Any  ):
												'''simple docstring'''






												pass






					@require_torch
					@slow
					def lowerCamelCase__							(       self    : str  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[str]      							=					0.2
												__UpperCAmelCase   :						List[Any]      							=					pipeline("""zero-shot-object-detection"""  )

												__UpperCAmelCase   :						Any      							=					object_detector(
												    """http://images.cocodataset.org/val2017/000000039769.jpg""" ,       candidate_labels=["""cat""", """remote""", """couch"""] ,       threshold=UpperCamelCase ,       )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        {"""score""": 0.2868, """label""": """cat""", """box""": {"""xmin""": 324, """ymin""": 20, """xmax""": 640, """ymax""": 373}},
												        {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 72, """xmax""": 177, """ymax""": 115}},
												        {"""score""": 0.2537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 55, """xmax""": 315, """ymax""": 472}},
												    ] ,       )






					@require_torch
					@slow
					def lowerCamelCase__							(       self    : int  ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[Any]      							=					2
												__UpperCAmelCase   :						Union[str, Any]      							=					pipeline("""zero-shot-object-detection"""  )

												__UpperCAmelCase   :						List[str]      							=					object_detector(
												    """http://images.cocodataset.org/val2017/000000039769.jpg""" ,       candidate_labels=["""cat""", """remote""", """couch"""] ,       top_k=UpperCamelCase ,       )
												self.assertEqual(
												    nested_simplify(UpperCamelCase ,       decimals=4  ) ,       [
												        {"""score""": 0.2868, """label""": """cat""", """box""": {"""xmin""": 324, """ymin""": 20, """xmax""": 640, """ymax""": 373}},
												        {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 72, """xmax""": 177, """ymax""": 115}},
												    ] ,       )
