





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand
def      A__       (    SCREAMING_SNAKE_CASE_   :      Namespace						)  ->  Optional[int]:






   """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 			__UpperCamelCase    (							A__    ):





     @staticmethod
     def 		UpperCamelCase(     _UpperCamelCase					):
        _UpperCAmelCase           =   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				,							):
        _UpperCAmelCase           =   logging.get_logger('''transformers-cli/converting'''					)

        self._logger.info(f'''Loading model {model_type}'''					)
        _UpperCAmelCase           =   model_type
        _UpperCAmelCase           =   tf_checkpoint
        _UpperCAmelCase           =   pytorch_dump_output
        _UpperCAmelCase           =   config
        _UpperCAmelCase           =   finetuning_task_name





     def 		UpperCamelCase(     self					):
        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           =   self._tf_checkpoint
              _UpperCAmelCase           =   ''''''
           else:
              _UpperCAmelCase           =   self._tf_checkpoint
              _UpperCAmelCase           =   ''''''
           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]'''					)






def      A__       (    SCREAMING_SNAKE_CASE_   :      int				,	SCREAMING_SNAKE_CASE_   :      int						)  ->  str:






   """simple docstring"""







   if a < 0 or b < 0:
      raise ValueError('''the value of both inputs must be positive'''						)

   _UpperCAmelCase           =   str(bin(SCREAMING_SNAKE_CASE_						)						)[2:]  # remove the leading "0b"
   _UpperCAmelCase           =   str(bin(SCREAMING_SNAKE_CASE_						)						)[2:]  # remove the leading "0b"

   _UpperCAmelCase           =   max(len(SCREAMING_SNAKE_CASE_						)				,	len(SCREAMING_SNAKE_CASE_						)						)

   return "0b" + "".join(
       str(int(char_a == '''1''' and char_b == '''1'''						)						)
       for char_a, char_b in zip(a_binary.zfill(SCREAMING_SNAKE_CASE_						)				,	b_binary.zfill(SCREAMING_SNAKE_CASE_						)						)						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()