import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()







def 			A__      (	snake_case_ :		Tuple       ,				snake_case_ :		Optional[int]       ,				snake_case_ :		Any       ,				snake_case_ :		str      ):
 # Initialise PyTorch model
 SCREAMING_SNAKE_CASE__:   str=      FunnelConfig.from_json_file(snake_case_      )
 print(F'Building PyTorch model from configuration: {config}'      )
 SCREAMING_SNAKE_CASE__:   Union[str, Any]=      FunnelBaseModel(snake_case_      ) if base_model else FunnelModel(snake_case_      )

 # Load weights from tf checkpoint
 load_tf_weights_in_funnel(snake_case_       ,				snake_case_       ,				snake_case_      )

 # Save pytorch-model
 print(F'Save PyTorch model to {pytorch_dump_path}'      )
 torch.save(model.state_dict()       ,				snake_case_      )


if __name__ == "__main__":
      lowercase_     :   Tuple 				=				argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
      )
      parser.add_argument(
          '--config_file',
          default=None,
          type=str,
          required=True,
          help='The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.',
      )
      parser.add_argument(
          '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
      )
      parser.add_argument(
          '--base_model', action='store_true', help='Whether you want just the base model (no decoder) or not.'
      )
      lowercase_     :   List[Any] 				=				parser.parse_args()
      convert_tf_checkpoint_to_pytorch(
          args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
      )


from ..utils import DummyObject, requires_backends






class 		_lowerCamelCase		(   metaclass=UpperCamelCase_    ):
    __a  =      ["torch", "scipy"]
    def __init__(  self , *lowerCAmelCase , **lowerCAmelCase   )       ->					Any:
     requires_backends(self , ['''torch''', '''scipy''']   )
    @classmethod
    def 						UpperCamelCase_				(  cls , *lowerCAmelCase , **lowerCAmelCase   )       ->					List[str]:
     requires_backends(cls , ['''torch''', '''scipy''']   )



    @classmethod
    def 						UpperCamelCase_				(  cls , *lowerCAmelCase , **lowerCAmelCase   )       ->					Tuple:
     requires_backends(cls , ['''torch''', '''scipy''']   )

