
import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
lowercase						:      List[Any]									= data_utils.TransfoXLTokenizer
lowercase						:      Tuple									= data_utils.TransfoXLCorpus
lowercase						:      str									= data_utils
lowercase						:      Any									= data_utils




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    int		,						_lowerCamelCase				:    str		,						_lowerCamelCase				:    Dict		,						_lowerCamelCase				:    Tuple)      ->					Dict:






							'''simple docstring'''





							if transfo_xl_dataset_file:
														# Convert a pre-processed corpus (see original TensorFlow repo)
														with open(_lowerCamelCase		,						"rb") as fp:
																					__UpperCamelCase			:     str         =      pickle.load(_lowerCamelCase		,						encoding="latin1")
														# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
														__UpperCamelCase			:     Optional[int]         =      pytorch_dump_folder_path + "/" + VOCAB_FILES_NAMES["pretrained_vocab_file"]
														print(F'Save vocabulary to {pytorch_vocab_dump_path}')
														__UpperCamelCase			:     Optional[Any]         =      corpus.vocab.__dict__
														torch.save(_lowerCamelCase		,						_lowerCamelCase)

														__UpperCamelCase			:     List[Any]         =      corpus.__dict__
														corpus_dict_no_vocab.pop("vocab"		,						_lowerCamelCase)
														__UpperCamelCase			:     int         =      pytorch_dump_folder_path + "/" + CORPUS_NAME
														print(F'Save dataset to {pytorch_dataset_dump_path}')
														torch.save(_lowerCamelCase		,						_lowerCamelCase)

							if tf_checkpoint_path:
														# Convert a pre-trained TensorFlow model
														__UpperCamelCase			:     str         =      os.path.abspath(_lowerCamelCase)
														__UpperCamelCase			:     List[Any]         =      os.path.abspath(_lowerCamelCase)

														print(F'Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.')
														# Initialise PyTorch model
														if transfo_xl_config_file == "":
																					__UpperCamelCase			:     List[str]         =      TransfoXLConfig()
														else:
																					__UpperCamelCase			:     str         =      TransfoXLConfig.from_json_file(_lowerCamelCase)
														print(F'Building PyTorch model from configuration: {config}')
														__UpperCamelCase			:     int         =      TransfoXLLMHeadModel(_lowerCamelCase)

														__UpperCamelCase			:     Dict         =      load_tf_weights_in_transfo_xl(_lowerCamelCase		,						_lowerCamelCase		,						_lowerCamelCase)
														# Save pytorch-model
														__UpperCamelCase			:     Tuple         =      os.path.join(_lowerCamelCase		,						_lowerCamelCase)
														__UpperCamelCase			:     int         =      os.path.join(_lowerCamelCase		,						_lowerCamelCase)
														print(F'Save PyTorch model to {os.path.abspath(_lowerCamelCase)}')
														torch.save(model.state_dict()		,						_lowerCamelCase)
														print(F'Save configuration file to {os.path.abspath(_lowerCamelCase)}')
														with open(_lowerCamelCase		,						"w"		,						encoding="utf-8") as f:
																					f.write(config.to_json_string())


if __name__ == "__main__":
		lowercase						:      List[str]									= argparse.ArgumentParser()
		parser.add_argument(
		    '--pytorch_dump_folder_path',
		    default=None,
		    type=str,
		    required=True,
		    help='Path to the folder to store the PyTorch model or dataset/vocab.',
		)
		parser.add_argument(
		    '--tf_checkpoint_path',
		    default='',
		    type=str,
		    help='An optional path to a TensorFlow checkpoint path to be converted.',
		)
		parser.add_argument(
		    '--transfo_xl_config_file',
		    default='',
		    type=str,
		    help=(
		        'An optional config json file corresponding to the pre-trained BERT model. \n'
		        'This specifies the model architecture.'
		    ),
		)
		parser.add_argument(
		    '--transfo_xl_dataset_file',
		    default='',
		    type=str,
		    help='An optional dataset file to be converted in a vocabulary.',
		)
		lowercase						:      Optional[int]									= parser.parse_args()
		convert_transfo_xl_checkpoint_to_pytorch(
		    args.tf_checkpoint_path,
		    args.transfo_xl_config_file,
		    args.pytorch_dump_folder_path,
		    args.transfo_xl_dataset_file,
		)

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch

from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer
from .base import PipelineTool




class 				lowerCamelCase__							(       __lowercase):




	'''simple docstring'''




	_A			=  'facebook/bart-large-mnli'
	_A			=  (
	    'This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which '
	    'should be the text to classify, and `labels`, which should be the list of labels to use for classification. '
	    'It returns the most likely label in the list of provided `labels` for the input text.'
	)
	_A			=  'text_classifier'
	_A			=  AutoTokenizer
	_A			=  AutoModelForSequenceClassification

	_A			=  ['text', ['text']]
	_A			=  ['text']







	def      _lowerCamelCase       (      self	:str		)	->				Tuple:
								super().setup()
								__UpperCamelCase			:     Any         =      self.model.config
								__UpperCamelCase			:     List[Any]         =      -1
								for idx, label in config.idalabel.items():
															if label.lower().startswith("entail"		):
																						__UpperCamelCase			:     Optional[Any]         =      int(a		)
								if self.entailment_id == -1:
															raise ValueError("Could not determine the entailment ID from the model config, please pass it at init."		)







	def      _lowerCamelCase       (      self	:Optional[int]  ,     a	:Dict  ,     a	:Optional[Any]		)	->				Optional[int]:
								__UpperCamelCase			:     str         =      labels
								return self.pre_processor(
								    [text] * len(a		)  ,     [f'This example is {label}' for label in labels]  ,     return_tensors="pt"  ,     padding="max_length"  ,     )







	def      _lowerCamelCase       (      self	:Any  ,     a	:Any		)	->				Optional[int]:
								__UpperCamelCase			:     Optional[int]         =      outputs.logits
								__UpperCamelCase			:     Dict         =      torch.argmax(logits[:, 2]		).item()
								return self._labels[label_id]