



"""simple docstring"""
import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    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.
SCREAMING_SNAKE_CASE_				= {"""LayoutLMv2Config""", """LayoutLMv3Config"""}




@is_pipeline_test
class 			snake_case_						(						unittest.TestCase				):
							__lowerCAmelCase    					=					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							__lowerCAmelCase    					=					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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






							@require_torch
							def snake_case_  (   self      ):
									a_     :      Optional[Any] 				=     pipeline(
									    task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="pt"      )

									a_     :      Optional[Any] 				=     text_classifier("This is great !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}]      )

									a_     :      Any 				=     text_classifier("This is great !"			,     top_k=2      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}]      )

									a_     :      Optional[Any] 				=     text_classifier(["This is great !", "This is bad"]			,     top_k=2      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [
									        [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
									        [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
									    ]			,     )

									a_     :      Any 				=     text_classifier("This is great !"			,     top_k=1      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}]      )

									# Legacy behavior
									a_     :      Union[str, Any] 				=     text_classifier("This is great !"			,     return_all_scores=a_      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}]      )

									a_     :      Optional[int] 				=     text_classifier("This is great !"			,     return_all_scores=a_      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [[{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}]]      )

									a_     :      Any 				=     text_classifier(["This is great !", "Something else"]			,     return_all_scores=a_      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [
									        [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
									        [{"label": "LABEL_0", "score": 0.504}, {"label": "LABEL_1", "score": 0.496}],
									    ]			,     )

									a_     :      List[str] 				=     text_classifier(["This is great !", "Something else"]			,     return_all_scores=a_      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [
									        {"label": "LABEL_0", "score": 0.504},
									        {"label": "LABEL_0", "score": 0.504},
									    ]			,     )






							@require_torch
							def snake_case_  (   self      ):
									import torch

									a_     :      int 				=     pipeline(
									    task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="pt"			,     device=torch.device("cpu"      )			,     )

									a_     :      Tuple 				=     text_classifier("This is great !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}]      )






							@require_tf
							def snake_case_  (   self      ):
									a_     :      str 				=     pipeline(
									    task="text-classification"			,     model="hf-internal-testing/tiny-random-distilbert"			,     framework="tf"      )

									a_     :      Tuple 				=     text_classifier("This is great !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "LABEL_0", "score": 0.504}]      )






							@slow
							@require_torch
							def snake_case_  (   self      ):
									a_     :      List[str] 				=     pipeline("text-classification"      )

									a_     :      int 				=     text_classifier("This is great !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "POSITIVE", "score": 1.0}]      )
									a_     :      Union[str, Any] 				=     text_classifier("This is bad !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "NEGATIVE", "score": 1.0}]      )
									a_     :      Dict 				=     text_classifier("Birds are a type of animal"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "POSITIVE", "score": 0.988}]      )






							@slow
							@require_tf
							def snake_case_  (   self      ):
									a_     :      Tuple 				=     pipeline("text-classification"			,     framework="tf"      )

									a_     :      Union[str, Any] 				=     text_classifier("This is great !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "POSITIVE", "score": 1.0}]      )
									a_     :      str 				=     text_classifier("This is bad !"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "NEGATIVE", "score": 1.0}]      )
									a_     :      str 				=     text_classifier("Birds are a type of animal"      )
									self.assertEqual(nested_simplify(a_      )			,     [{"label": "POSITIVE", "score": 0.988}]      )






							def snake_case_  (   self			,     a_			,     a_			,     a_      ):
									a_     :      str 				=     TextClassificationPipeline(model=a_			,     tokenizer=a_      )
									return text_classifier, ["HuggingFace is in", "This is another test"]






							def snake_case_  (   self			,     a_			,     a_      ):
									a_     :      Tuple 				=     text_classifier.model
									# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
									a_     :      Dict 				=     "HuggingFace is in"
									a_     :      Optional[int] 				=     text_classifier(a_      )

									self.assertEqual(nested_simplify(a_      )			,     [{"label": ANY(a_      ), "score": ANY(a_      )}]      )
									self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()      )

									a_     :      Any 				=     ["HuggingFace is in ", "Paris is in France"]
									a_     :      Any 				=     text_classifier(a_      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [{"label": ANY(a_      ), "score": ANY(a_      )}, {"label": ANY(a_      ), "score": ANY(a_      )}]			,     )
									self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()      )
									self.assertTrue(outputs[1]["label"] in model.config.idalabel.values()      )

									# Forcing to get all results with `top_k=None`
									# This is NOT the legacy format
									a_     :      Tuple 				=     text_classifier(a_			,     top_k=a_      )
									a_     :      Union[str, Any] 				=     len(model.config.idalabel.values()      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [[{"label": ANY(a_      ), "score": ANY(a_      )}] * N, [{"label": ANY(a_      ), "score": ANY(a_      )}] * N]			,     )

									a_     :      List[str] 				=     {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
									a_     :      Dict 				=     text_classifier(a_      )
									self.assertEqual(
									    nested_simplify(a_      )			,     {"label": ANY(a_      ), "score": ANY(a_      )}			,     )
									self.assertTrue(outputs["label"] in model.config.idalabel.values()      )

									# This might be used a text pair, but tokenizer + pipe interaction
									# makes it hard to understand that it's not using the pair properly
									# https://github.com/huggingface/transformers/issues/17305
									# We disabled this usage instead as it was outputting wrong outputs.
									a_     :      Any 				=     [["HuggingFace is in ", "Paris is in France"]]
									with self.assertRaises(a_      ):
											text_classifier(a_      )

									# This used to be valid for doing text pairs
									# We're keeping it working because of backward compatibility
									a_     :      Optional[int] 				=     text_classifier([[["HuggingFace is in ", "Paris is in France"]]]      )
									self.assertEqual(
									    nested_simplify(a_      )			,     [{"label": ANY(a_      ), "score": ANY(a_      )}]			,     )
									self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()      )




"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_				= {
    """configuration_bigbird_pegasus""": [
        """BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BigBirdPegasusConfig""",
        """BigBirdPegasusOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE_				= [
					    """BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """BigBirdPegasusForCausalLM""",
					    """BigBirdPegasusForConditionalGeneration""",
					    """BigBirdPegasusForQuestionAnswering""",
					    """BigBirdPegasusForSequenceClassification""",
					    """BigBirdPegasusModel""",
					    """BigBirdPegasusPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_bigbird_pegasus import (
					    BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    BigBirdPegasusConfig,
					    BigBirdPegasusOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_bigbird_pegasus import (
										    BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
										    BigBirdPegasusForCausalLM,
										    BigBirdPegasusForConditionalGeneration,
										    BigBirdPegasusForQuestionAnswering,
										    BigBirdPegasusForSequenceClassification,
										    BigBirdPegasusModel,
										    BigBirdPegasusPreTrainedModel,
										)


else:
					import sys

					SCREAMING_SNAKE_CASE_				= _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)