
import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
					import tensorflow as tf

					from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
					from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

_UpperCAmelCase      :				Optional[Any]          = logging.get_logger(__name__)


class        lowercase      (	enum.Enum     ):
		__lowercase : List[Any]			  =       0
		__lowercase : Dict			  =       1






@add_end_docstrings(_SCREAMING_SNAKE_CASE     )
class        lowercase      (	_SCREAMING_SNAKE_CASE     ):
		__lowercase : Any			  =       "generated"



		def __init__(				self       ,   *A_       ,   **A_ )						->      Optional[int]:
				"""simple docstring"""
				super().__init__(*A_       ,   **A_ )

				self.check_model_type(
				    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
				    if self.framework == 'tf'
				    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING )



		def __UpperCamelCase				(				self       ,   A_=None       ,   A_=None       ,   A_=None       ,   A_=None       ,   A_=None       ,   A_=None       ,   **A_       ,   )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  {}
				if truncation is not None:
						UpperCamelCase						=  truncation

				UpperCamelCase						=  generate_kwargs

				UpperCamelCase						=  {}
				if return_tensors is not None and return_type is None:
						UpperCamelCase						=  ReturnType.TENSORS if return_tensors else ReturnType.TEXT
				if return_type is not None:
						UpperCamelCase						=  return_type

				if clean_up_tokenization_spaces is not None:
						UpperCamelCase						=  clean_up_tokenization_spaces

				if stop_sequence is not None:
						UpperCamelCase						=  self.tokenizer.encode(A_       ,   add_special_tokens=A_ )
						if len(A_ ) > 1:
								warnings.warn(
								    'Stopping on a multiple token sequence is not yet supported on transformers. The first token of'
								    ' the stop sequence will be used as the stop sequence string in the interim.' )
						UpperCamelCase						=  stop_sequence_ids[0]

				return preprocess_params, forward_params, postprocess_params



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_ )						->      List[Any]:
				"""simple docstring"""
				return True



		def __UpperCamelCase				(				self       ,   *A_       ,   A_ )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  self.model.config.prefix if self.model.config.prefix is not None else ''
				if isinstance(args[0]       ,   A_ ):
						if self.tokenizer.pad_token_id is None:
								raise ValueError('Please make sure that the tokenizer has a pad_token_id when using a batch input' )
						UpperCamelCase						=  ([prefix + arg for arg in args[0]],)
						UpperCamelCase						=  True

				elif isinstance(args[0]       ,   A_ ):
						UpperCamelCase						=  (prefix + args[0],)
						UpperCamelCase						=  False
				else:
						raise ValueError(
						    F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`''' )
				UpperCamelCase						=  self.tokenizer(*A_       ,   padding=A_       ,   truncation=A_       ,   return_tensors=self.framework )
				# This is produced by tokenizers but is an invalid generate kwargs
				if "token_type_ids" in inputs:
						del inputs["token_type_ids"]
				return inputs



		def __call__(				self       ,   *A_       ,   **A_ )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  super().__call__(*A_       ,   **A_ )
				if (
				    isinstance(args[0]       ,   A_ )
				    and all(isinstance(A_       ,   A_ ) for el in args[0] )
				    and all(len(A_ ) == 1 for res in result )
				):
						return [res[0] for res in result]
				return result



		def __UpperCamelCase				(				self       ,   A_       ,   A_=TruncationStrategy.DO_NOT_TRUNCATE       ,   **A_ )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  self._parse_and_tokenize(A_       ,   truncation=A_       ,   **A_ )
				return inputs



		def __UpperCamelCase				(				self       ,   A_       ,   **A_ )						->      int:
				"""simple docstring"""
				if self.framework == "pt":
						UpperCamelCase			,						UpperCamelCase						=  model_inputs['input_ids'].shape
				elif self.framework == "tf":
						UpperCamelCase			,						UpperCamelCase						=  tf.shape(model_inputs['input_ids'] ).numpy()

				UpperCamelCase						=  generate_kwargs.get('min_length'       ,   self.model.config.min_length )
				UpperCamelCase						=  generate_kwargs.get('max_length'       ,   self.model.config.max_length )
				self.check_inputs(A_       ,   generate_kwargs['min_length']       ,   generate_kwargs['max_length'] )
				UpperCamelCase						=  self.model.generate(**A_       ,   **A_ )
				UpperCamelCase						=  output_ids.shape[0]
				if self.framework == "pt":
						UpperCamelCase						=  output_ids.reshape(A_       ,   out_b // in_b       ,   *output_ids.shape[1:] )
				elif self.framework == "tf":
						UpperCamelCase						=  tf.reshape(A_       ,   (in_b, out_b // in_b, *output_ids.shape[1:]) )
				return {"output_ids": output_ids}



		def __UpperCamelCase				(				self       ,   A_       ,   A_=ReturnType.TEXT       ,   A_=False )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  []
				for output_ids in model_outputs["output_ids"][0]:
						if return_type == ReturnType.TENSORS:
								UpperCamelCase						=  {F'''{self.return_name}_token_ids''': output_ids}
						elif return_type == ReturnType.TEXT:
								UpperCamelCase						=  {
								    F'''{self.return_name}_text''': self.tokenizer.decode(
								        A_       ,   skip_special_tokens=A_       ,   clean_up_tokenization_spaces=A_       ,   )
								}
						records.append(A_ )
				return records






@add_end_docstrings(_SCREAMING_SNAKE_CASE     )
class        lowercase      (	_SCREAMING_SNAKE_CASE     ):
		__lowercase : Optional[int]			  =       "summary"



		def __call__(				self       ,   *A_       ,   **A_ )						->      List[str]:
				"""simple docstring"""
				return super().__call__(*A_       ,   **A_ )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_ )						->      bool:
				"""simple docstring"""
				if max_length < min_length:
						logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.''' )

				if input_length < max_length:
						logger.warning(
						    F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
						    'a summarization task, where outputs shorter than the input are typically wanted, you might '
						    F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})''' )






@add_end_docstrings(_SCREAMING_SNAKE_CASE     )
class        lowercase      (	_SCREAMING_SNAKE_CASE     ):
		__lowercase : int			  =       "translation"



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_ )						->      str:
				"""simple docstring"""
				if input_length > 0.9 * max_length:
						logger.warning(
						    F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
						    'increasing your max_length manually, e.g. translator(\'...\', max_length=400)' )
				return True



		def __UpperCamelCase				(				self       ,   *A_       ,   A_=TruncationStrategy.DO_NOT_TRUNCATE       ,   A_=None       ,   A_=None )						->      Optional[int]:
				"""simple docstring"""
				if getattr(self.tokenizer       ,   '_build_translation_inputs'       ,   A_ ):
						return self.tokenizer._build_translation_inputs(
						    *A_       ,   return_tensors=self.framework       ,   truncation=A_       ,   src_lang=A_       ,   tgt_lang=A_ )
				else:
						return super()._parse_and_tokenize(*A_       ,   truncation=A_ )



		def __UpperCamelCase				(				self       ,   A_=None       ,   A_=None       ,   **A_ )						->      Tuple:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase						=  super()._sanitize_parameters(**A_ )
				if src_lang is not None:
						UpperCamelCase						=  src_lang
				if tgt_lang is not None:
						UpperCamelCase						=  tgt_lang
				if src_lang is None and tgt_lang is None:
						# Backward compatibility, direct arguments use is preferred.
						UpperCamelCase						=  kwargs.get('task'       ,   self.task )
						UpperCamelCase						=  task.split('_' )
						if task and len(A_ ) == 4:
								# translation, XX, to YY
								UpperCamelCase						=  items[1]
								UpperCamelCase						=  items[3]
				return preprocess_params, forward_params, postprocess_params



		def __call__(				self       ,   *A_       ,   **A_ )						->      List[str]:
				"""simple docstring"""
				return super().__call__(*A_       ,   **A_ )


from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


_UpperCAmelCase      :				Any          = "\\n@inproceedings{wang2019glue,\n  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n  note={In the Proceedings of ICLR.},\n  year={2019}\n}\n"

_UpperCAmelCase      :				str          = "\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n"

_UpperCAmelCase      :				List[str]          = "\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"pearson\": Pearson Correlation\n    \"spearmanr\": Spearman Correlation\n    \"matthews_correlation\": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'stsb')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})\n    {'pearson': 1.0, 'spearmanr': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'cola')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"


def    A (      lowercase					, lowercase				)     ->						List[str]:
		'''simple docstring'''

		return float((preds == labels).mean()				)


def    A (      lowercase					, lowercase				)     ->						Tuple:
		'''simple docstring'''

		UpperCamelCase						=  simple_accuracy(lowercase					, lowercase				)
		UpperCamelCase						=  float(fa_score(y_true=lowercase					, y_pred=lowercase				)				)
		return {
		    "accuracy": acc,
		    "f1": fa,
		}


def    A (      lowercase					, lowercase				)     ->						Optional[int]:
		'''simple docstring'''

		UpperCamelCase						=  float(pearsonr(lowercase					, lowercase				)[0]				)
		UpperCamelCase						=  float(spearmanr(lowercase					, lowercase				)[0]				)
		return {
		    "pearson": pearson_corr,
		    "spearmanr": spearman_corr,
		}


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,     _KWARGS_DESCRIPTION     )
class        lowercase      (	datasets.Metric     ):



		def __UpperCamelCase				(				self )						->      Optional[Any]:
				"""simple docstring"""
				if self.config_name not in [
				    "sst2",
				    "mnli",
				    "mnli_mismatched",
				    "mnli_matched",
				    "cola",
				    "stsb",
				    "mrpc",
				    "qqp",
				    "qnli",
				    "rte",
				    "wnli",
				    "hans",
				]:
						raise KeyError(
						    'You should supply a configuration name selected in '
						    '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
						    '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]' )
				return datasets.MetricInfo(
				    description=_DESCRIPTION       ,   citation=_CITATION       ,   inputs_description=_KWARGS_DESCRIPTION       ,   features=datasets.Features(
				        {
				            'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32' ),
				            'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32' ),
				        } )       ,   codebase_urls=[]       ,   reference_urls=[]       ,   format='numpy'       ,   )



		def __UpperCamelCase				(				self       ,   A_       ,   A_ )						->      Any:
				"""simple docstring"""
				if self.config_name == "cola":
						return {"matthews_correlation": matthews_corrcoef(A_       ,   A_ )}
				elif self.config_name == "stsb":
						return pearson_and_spearman(A_       ,   A_ )
				elif self.config_name in ["mrpc", "qqp"]:
						return acc_and_fa(A_       ,   A_ )
				elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
						return {"accuracy": simple_accuracy(A_       ,   A_ )}
				else:
						raise KeyError(
						    'You should supply a configuration name selected in '
						    '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
						    '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]' )
