

import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()


def 							__lowerCAmelCase     (							_UpperCamelCase		:	List[Any]		,				_UpperCamelCase		:	Any		,				_UpperCamelCase		:	Dict						)		->				str:
 '''simple docstring'''


 if openai_config_file == "":
  SCREAMING_SNAKE_CASE		    =      OpenAIGPTConfig()
 else:
  SCREAMING_SNAKE_CASE		    =      OpenAIGPTConfig.from_json_file(_UpperCamelCase						)
 SCREAMING_SNAKE_CASE		    =      OpenAIGPTModel(_UpperCamelCase						)

 # Load weights from numpy
 load_tf_weights_in_openai_gpt(_UpperCamelCase		,				_UpperCamelCase		,				_UpperCamelCase						)

 # Save pytorch-model
 SCREAMING_SNAKE_CASE		    =      pytorch_dump_folder_path + '/' + WEIGHTS_NAME
 SCREAMING_SNAKE_CASE		    =      pytorch_dump_folder_path + '/' + CONFIG_NAME
 print(f"""Save PyTorch model to {pytorch_weights_dump_path}"""						)
 torch.save(model.state_dict()		,				_UpperCamelCase						)
 print(f"""Save configuration file to {pytorch_config_dump_path}"""						)
 with open(_UpperCamelCase		,				'w'		,				encoding='utf-8'						) as f:
  f.write(config.to_json_string()						)


if __name__ == "__main__":
      a_     :    Dict     		=   argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--openai_checkpoint_folder_path",
          default=None,
          type=str,
          required=True,
          help="Path to the TensorFlow checkpoint path.",
      )
      parser.add_argument(
          "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
      )
      parser.add_argument(
          "--openai_config_file",
          default="",
          type=str,
          help=(
              "An optional config json file corresponding to the pre-trained OpenAI model. \n"
              "This specifies the model architecture."
          ),
      )
      a_     :    Any     		=   parser.parse_args()
      convert_openai_checkpoint_to_pytorch(
          args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
      )




import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class   UpperCamelCase			(  SCREAMING_SNAKE_CASE ):
    __UpperCamelCase    =["image_processor", "tokenizer"]
    __UpperCamelCase    ="CLIPImageProcessor"
    __UpperCamelCase    =("CLIPTokenizer", "CLIPTokenizerFast")

    def __init__(      self			:   int				,     snake_case__			:   List[Any]=None				,     snake_case__			:   Any=None				,     **snake_case__			:   Any     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      None
     if "feature_extractor" in kwargs:
      warnings.warn(
          'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
          ' instead.'				,     snake_case__				,     )
      SCREAMING_SNAKE_CASE		    =      kwargs.pop('feature_extractor'     )

     SCREAMING_SNAKE_CASE		    =      image_processor if image_processor is not None else feature_extractor
     if image_processor is None:
      raise ValueError('You need to specify an `image_processor`.'     )
     if tokenizer is None:
      raise ValueError('You need to specify a `tokenizer`.'     )

     super().__init__(snake_case__				,     snake_case__     )

    def __call__(      self			:   List[Any]				,     snake_case__			:   Tuple=None				,     snake_case__			:   Optional[int]=None				,     snake_case__			:   List[str]=None				,     **snake_case__			:   Dict     ):

     """simple docstring"""






     if text is None and images is None:
      raise ValueError('You have to specify either text or images. Both cannot be none.'     )

     if text is not None:
      SCREAMING_SNAKE_CASE		    =      self.tokenizer(snake_case__				,     return_tensors=snake_case__				,     **snake_case__     )

     if images is not None:
      SCREAMING_SNAKE_CASE		    =      self.image_processor(snake_case__				,     return_tensors=snake_case__				,     **snake_case__     )

     if text is not None and images is not None:
      SCREAMING_SNAKE_CASE		    =      image_features.pixel_values
      return encoding
     elif text is not None:
      return encoding
     else:
      return BatchEncoding(data=dict(**snake_case__     )				,     tensor_type=snake_case__     )

    def UpperCamelCase      (      self			:   Union[str, Any]				,     *snake_case__			:   Optional[Any]				,     **snake_case__			:   Optional[int]     ):

     """simple docstring"""






     return self.tokenizer.batch_decode(*snake_case__				,     **snake_case__     )

    def UpperCamelCase      (      self			:   Dict				,     *snake_case__			:   Optional[Any]				,     **snake_case__			:   Dict     ):

     """simple docstring"""






     return self.tokenizer.decode(*snake_case__				,     **snake_case__     )

    @property
    def UpperCamelCase      (      self			:   Any     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      self.tokenizer.model_input_names
     SCREAMING_SNAKE_CASE		    =      self.image_processor.model_input_names
     return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names     )     )

    @property
    def UpperCamelCase      (      self			:   int     ):

     """simple docstring"""






     warnings.warn(
         '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'				,     snake_case__				,     )
     return self.image_processor_class




    @property
    def UpperCamelCase      (      self			:   Tuple     ):

     """simple docstring"""






     warnings.warn(
         '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'				,     snake_case__				,     )
     return self.image_processor

