






"""simple docstring"""
import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
lowerCamelCase_       			=   {'''LayoutLMv2Config''', '''LayoutLMv3Config'''}







@is_pipeline_test
class     UpperCamelCase_ (unittest.TestCase  ):
	__magic_name__			   =       MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
	__magic_name__			   =       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

	if model_mapping is not None:
		__magic_name__			   =       {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
	if tf_model_mapping is not None:
		__magic_name__			   =       {
		    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
		}





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[Any]			,			lowerCAmelCase_      :				str			,			lowerCAmelCase_      :				Any			,			lowerCAmelCase_      :				Optional[int]		)		->    Optional[Any]:
				UpperCAmelCase_  :				str      =      ZeroShotClassificationPipeline(
				    model=lowerCAmelCase_			,			tokenizer=lowerCAmelCase_			,			candidate_labels=["polics", "health"]		)
				return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[Any]			,			lowerCAmelCase_      :				Optional[Any]			,			lowerCAmelCase_      :				int		)		->    str:
				UpperCAmelCase_  :				List[str]      =      classifier("Who are you voting for in 2020?"			,			candidate_labels="politics"		)
				self.assertEqual(lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		)]}		)

				# No kwarg
				UpperCAmelCase_  :				List[str]      =      classifier("Who are you voting for in 2020?"			,			["politics"]		)
				self.assertEqual(lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		)]}		)

				UpperCAmelCase_  :				Optional[int]      =      classifier("Who are you voting for in 2020?"			,			candidate_labels=["politics"]		)
				self.assertEqual(lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		)]}		)

				UpperCAmelCase_  :				int      =      classifier("Who are you voting for in 2020?"			,			candidate_labels="politics, public health"		)
				self.assertEqual(
				    lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)]}		)
				self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]		)		)			,			1.0		)

				UpperCAmelCase_  :				Tuple      =      classifier("Who are you voting for in 2020?"			,			candidate_labels=["politics", "public health"]		)
				self.assertEqual(
				    lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)]}		)
				self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]		)		)			,			1.0		)

				UpperCAmelCase_  :				Union[str, Any]      =      classifier(
				    "Who are you voting for in 2020?"			,			candidate_labels="politics"			,			hypothesis_template="This text is about {}"		)
				self.assertEqual(lowerCAmelCase_			,			{"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		)]}		)

				# https://github.com/huggingface/transformers/issues/13846
				UpperCAmelCase_  :				List[str]      =      classifier(["I am happy"]			,			["positive", "negative"]		)
				self.assertEqual(
				    lowerCAmelCase_			,			[
				        {"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)]}
				        for i in range(1		)
				    ]			,			)
				UpperCAmelCase_  :				Optional[Any]      =      classifier(["I am happy", "I am sad"]			,			["positive", "negative"]		)
				self.assertEqual(
				    lowerCAmelCase_			,			[
				        {"sequence": ANY(lowerCAmelCase_		), "labels": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)], "scores": [ANY(lowerCAmelCase_		), ANY(lowerCAmelCase_		)]}
				        for i in range(2		)
				    ]			,			)

				with self.assertRaises(lowerCAmelCase_		):
							classifier(""			,			candidate_labels="politics"		)

				with self.assertRaises(lowerCAmelCase_		):
							classifier(lowerCAmelCase_			,			candidate_labels="politics"		)

				with self.assertRaises(lowerCAmelCase_		):
							classifier("Who are you voting for in 2020?"			,			candidate_labels=""		)

				with self.assertRaises(lowerCAmelCase_		):
							classifier("Who are you voting for in 2020?"			,			candidate_labels=lowerCAmelCase_		)

				with self.assertRaises(lowerCAmelCase_		):
							classifier(
							    "Who are you voting for in 2020?"			,			candidate_labels="politics"			,			hypothesis_template="Not formatting template"			,			)

				with self.assertRaises(lowerCAmelCase_		):
							classifier(
							    "Who are you voting for in 2020?"			,			candidate_labels="politics"			,			hypothesis_template=lowerCAmelCase_			,			)

				self.run_entailment_id(lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[Any]			,			lowerCAmelCase_      :				Pipeline		)		->    List[Any]:
				UpperCAmelCase_  :				Dict      =      zero_shot_classifier.model.config
				UpperCAmelCase_  :				Optional[int]      =      config.labelaid
				UpperCAmelCase_  :				Optional[Any]      =      zero_shot_classifier.entailment_id

				UpperCAmelCase_  :				Tuple      =      {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
				self.assertEqual(zero_shot_classifier.entailment_id			,			-1		)

				UpperCAmelCase_  :				List[Any]      =      {"entailment": 0, "neutral": 1, "contradiction": 2}
				self.assertEqual(zero_shot_classifier.entailment_id			,			0		)

				UpperCAmelCase_  :				List[str]      =      {"ENTAIL": 0, "NON-ENTAIL": 1}
				self.assertEqual(zero_shot_classifier.entailment_id			,			0		)

				UpperCAmelCase_  :				str      =      {"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
				self.assertEqual(zero_shot_classifier.entailment_id			,			2		)

				UpperCAmelCase_  :				int      =      original_labelaid
				self.assertEqual(lowerCAmelCase_			,			zero_shot_classifier.entailment_id		)





	@require_torch
	def   _SCREAMING_SNAKE_CASE   (   self      :				Tuple		)		->    Optional[Any]:
				UpperCAmelCase_  :				Optional[Any]      =      pipeline(
				    "zero-shot-classification"			,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"			,			framework="pt"			,			)
				# There was a regression in 4.10 for this
				# Adding a test so we don't make the mistake again.
				# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
				zero_shot_classifier(
				    "Who are you voting for in 2020?" * 100			,			candidate_labels=["politics", "public health", "science"]		)





	@require_torch
	def   _SCREAMING_SNAKE_CASE   (   self      :				Tuple		)		->    List[Any]:
				UpperCAmelCase_  :				str      =      pipeline(
				    "zero-shot-classification"			,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"			,			framework="pt"			,			)
				UpperCAmelCase_  :				int      =      zero_shot_classifier(
				    "Who are you voting for in 2020?"			,			candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": "Who are you voting for in 2020?",
				        "labels": ["science", "public health", "politics"],
				        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
				    }			,			)





	@require_tf
	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    Tuple:
				UpperCAmelCase_  :				Optional[Any]      =      pipeline(
				    "zero-shot-classification"			,			model="sshleifer/tiny-distilbert-base-cased-distilled-squad"			,			framework="tf"			,			)
				UpperCAmelCase_  :				str      =      zero_shot_classifier(
				    "Who are you voting for in 2020?"			,			candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": "Who are you voting for in 2020?",
				        "labels": ["science", "public health", "politics"],
				        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
				    }			,			)





	@slow
	@require_torch
	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[Any]		)		->    Tuple:
				UpperCAmelCase_  :				List[Any]      =      pipeline("zero-shot-classification"			,			model="roberta-large-mnli"			,			framework="pt"		)
				UpperCAmelCase_  :				List[str]      =      zero_shot_classifier(
				    "Who are you voting for in 2020?"			,			candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": "Who are you voting for in 2020?",
				        "labels": ["politics", "public health", "science"],
				        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
				    }			,			)
				UpperCAmelCase_  :				List[str]      =      zero_shot_classifier(
				    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
				    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
				    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
				    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
				    " machine translation tasks show these models to be superior in quality while being more parallelizable"
				    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
				    " English-to-German translation task, improving over the existing best results, including ensembles by"
				    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
				    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
				    " fraction of the training costs of the best models from the literature. We show that the Transformer"
				    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
				    " large and limited training data."			,			candidate_labels=["machine learning", "statistics", "translation", "vision"]			,			multi_label=lowerCAmelCase_			,			)
				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": (
				            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
				            " networks in an encoder-decoder configuration. The best performing models also connect the"
				            " encoder and decoder through an attention mechanism. We propose a new simple network"
				            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
				            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
				            " superior in quality while being more parallelizable and requiring significantly less time to"
				            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
				            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
				            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
				            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
				            " costs of the best models from the literature. We show that the Transformer generalizes well to"
				            " other tasks by applying it successfully to English constituency parsing both with large and"
				            " limited training data."
				        ),
				        "labels": ["translation", "machine learning", "vision", "statistics"],
				        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
				    }			,			)





	@slow
	@require_tf
	def   _SCREAMING_SNAKE_CASE   (   self      :				Dict		)		->    Dict:
				UpperCAmelCase_  :				Tuple      =      pipeline("zero-shot-classification"			,			model="roberta-large-mnli"			,			framework="tf"		)
				UpperCAmelCase_  :				int      =      zero_shot_classifier(
				    "Who are you voting for in 2020?"			,			candidate_labels=["politics", "public health", "science"]		)

				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": "Who are you voting for in 2020?",
				        "labels": ["politics", "public health", "science"],
				        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
				    }			,			)
				UpperCAmelCase_  :				List[Any]      =      zero_shot_classifier(
				    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
				    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
				    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
				    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
				    " machine translation tasks show these models to be superior in quality while being more parallelizable"
				    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
				    " English-to-German translation task, improving over the existing best results, including ensembles by"
				    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
				    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
				    " fraction of the training costs of the best models from the literature. We show that the Transformer"
				    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
				    " large and limited training data."			,			candidate_labels=["machine learning", "statistics", "translation", "vision"]			,			multi_label=lowerCAmelCase_			,			)
				self.assertEqual(
				    nested_simplify(lowerCAmelCase_		)			,			{
				        "sequence": (
				            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
				            " networks in an encoder-decoder configuration. The best performing models also connect the"
				            " encoder and decoder through an attention mechanism. We propose a new simple network"
				            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
				            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
				            " superior in quality while being more parallelizable and requiring significantly less time to"
				            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
				            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
				            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
				            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
				            " costs of the best models from the literature. We show that the Transformer generalizes well to"
				            " other tasks by applying it successfully to English constituency parsing both with large and"
				            " limited training data."
				        ),
				        "labels": ["translation", "machine learning", "vision", "statistics"],
				        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
				    }			,			)











"""simple docstring"""
import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


lowerCamelCase_       			=   logging.getLogger()







@unittest.skip('''Temporarily disable the doc tests.'''  )
@require_torch
@require_tf
@slow
class     UpperCamelCase_ (unittest.TestCase  ):





	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]			,			lowerCAmelCase_      :				Path			,			lowerCAmelCase_      :				Union[str, None] = None			,			lowerCAmelCase_      :				Union[List[str], None] = None			,			lowerCAmelCase_      :				Union[str, List[str], None] = None			,			lowerCAmelCase_      :				bool = True			,			)		->    Tuple:
				UpperCAmelCase_  :				Optional[Any]      =      [file for file in os.listdir(lowerCAmelCase_		) if os.path.isfile(os.path.join(lowerCAmelCase_			,			lowerCAmelCase_		)		)]

				if identifier is not None:
							UpperCAmelCase_  :				Optional[int]      =      [file for file in files if identifier in file]

				if n_identifier is not None:
							if isinstance(lowerCAmelCase_			,			lowerCAmelCase_		):
										for n_ in n_identifier:
													UpperCAmelCase_  :				List[Any]      =      [file for file in files if n_ not in file]
							else:
										UpperCAmelCase_  :				Optional[Any]      =      [file for file in files if n_identifier not in file]

				UpperCAmelCase_  :				List[Any]      =      ignore_files or []
				ignore_files.append("__init__.py"		)
				UpperCAmelCase_  :				Optional[Any]      =      [file for file in files if file not in ignore_files]

				for file in files:
							# Open all files
							print("Testing"			,			lowerCAmelCase_		)

							if only_modules:
										UpperCAmelCase_  :				str      =      file.split("."		)[0]
										try:
													UpperCAmelCase_  :				Tuple      =      getattr(lowerCAmelCase_			,			lowerCAmelCase_		)
													UpperCAmelCase_  :				int      =      doctest.DocTestSuite(lowerCAmelCase_		)
													UpperCAmelCase_  :				str      =      unittest.TextTestRunner().run(lowerCAmelCase_		)
													self.assertIs(len(result.failures		)			,			0		)
										except AttributeError:
													logger.info(f"""{module_identifier} is not a module."""		)
							else:
										UpperCAmelCase_  :				List[Any]      =      doctest.testfile(str(".." / directory / file		)			,			optionflags=doctest.ELLIPSIS		)
										self.assertIs(result.failed			,			0		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    List[Any]:
				UpperCAmelCase_  :				Optional[int]      =      Path("src/transformers"		)
				UpperCAmelCase_  :				List[Any]      =      "modeling"
				UpperCAmelCase_  :				Tuple      =      [
				    "modeling_ctrl.py",
				    "modeling_tf_ctrl.py",
				]
				self.analyze_directory(lowerCAmelCase_			,			identifier=lowerCAmelCase_			,			ignore_files=lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    List[Any]:
				UpperCAmelCase_  :				List[str]      =      Path("src/transformers"		)
				UpperCAmelCase_  :				int      =      "tokenization"
				self.analyze_directory(lowerCAmelCase_			,			identifier=lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[Any]		)		->    Optional[Any]:
				UpperCAmelCase_  :				int      =      Path("src/transformers"		)
				UpperCAmelCase_  :				Any      =      "configuration"
				self.analyze_directory(lowerCAmelCase_			,			identifier=lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Any		)		->    Any:
				UpperCAmelCase_  :				int      =      Path("src/transformers"		)
				UpperCAmelCase_  :				List[Any]      =      ["configuration", "modeling", "tokenization"]
				self.analyze_directory(lowerCAmelCase_			,			n_identifier=lowerCAmelCase_		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[str]		)		->    Dict:
				UpperCAmelCase_  :				List[str]      =      Path("docs/source"		)
				UpperCAmelCase_  :				int      =      ["favicon.ico"]
				self.analyze_directory(lowerCAmelCase_			,			ignore_files=lowerCAmelCase_			,			only_modules=lowerCAmelCase_		)



