



"""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.
lowerCAmelCase_   						=   {'LayoutLMv2Config', 'LayoutLMv3Config'}
@is_pipeline_test
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[Any]   	=				MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
		lowerCAmelCase			:					List[Any]   	=				TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

		if model_mapping is not None:
				lowerCAmelCase			:					Tuple   	=				{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
		if tf_model_mapping is not None:
				lowerCAmelCase			:					Optional[Any]   	=				{
				    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
				}







		@require_torch
		def 					UpperCAmelCase    (	self						:  Dict						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			pipeline(
				    task='''text-classification'''			,model='''hf-internal-testing/tiny-random-distilbert'''			,framework='''pt'''						)

				lowercase__   :    Union[str, Any]				=			text_classifier('''This is great !'''						)
				self.assertEqual(nested_simplify(_snake_case						)			,[{'''label''': '''LABEL_0''', '''score''': 0.504}]						)

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

				lowercase__   :    Tuple				=			text_classifier(['''This is great !''', '''This is bad''']			,top_k=2						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,[
				        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
				        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
				    ]			,)

				lowercase__   :    Tuple				=			text_classifier('''This is great !'''			,top_k=1						)
				self.assertEqual(nested_simplify(_snake_case						)			,[{'''label''': '''LABEL_0''', '''score''': 0.504}]						)

				# Legacy behavior
				lowercase__   :    Dict				=			text_classifier('''This is great !'''			,return_all_scores=_snake_case						)
				self.assertEqual(nested_simplify(_snake_case						)			,[{'''label''': '''LABEL_0''', '''score''': 0.504}]						)

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

				lowercase__   :    Dict				=			text_classifier(['''This is great !''', '''Something else''']			,return_all_scores=_snake_case						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,[
				        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
				        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
				    ]			,)

				lowercase__   :    Dict				=			text_classifier(['''This is great !''', '''Something else''']			,return_all_scores=_snake_case						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,[
				        {'''label''': '''LABEL_0''', '''score''': 0.504},
				        {'''label''': '''LABEL_0''', '''score''': 0.504},
				    ]			,)







		@require_torch
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Tuple:






				"""simple docstring"""



				import torch

				lowercase__   :    List[str]				=			pipeline(
				    task='''text-classification'''			,model='''hf-internal-testing/tiny-random-distilbert'''			,framework='''pt'''			,device=torch.device('''cpu'''						)			,)

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







		@require_tf
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			pipeline(
				    task='''text-classification'''			,model='''hf-internal-testing/tiny-random-distilbert'''			,framework='''tf'''						)

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







		@slow
		@require_torch
		def 					UpperCAmelCase    (	self						:  str						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			pipeline('''text-classification'''						)

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







		@slow
		@require_tf
		def 					UpperCAmelCase    (	self						:  str						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    str				=			pipeline('''text-classification'''			,framework='''tf'''						)

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







		def 					UpperCAmelCase    (	self						:  List[Any]			,_snake_case						:  str			,_snake_case						:  Union[str, Any]			,_snake_case						:  Tuple						)					->		str:






				"""simple docstring"""



				lowercase__   :    Dict				=			TextClassificationPipeline(model=_snake_case			,tokenizer=_snake_case						)
				return text_classifier, ["HuggingFace is in", "This is another test"]







		def 					UpperCAmelCase    (	self						:  int			,_snake_case						:  Optional[int]			,_snake_case						:  str						)					->		str:






				"""simple docstring"""



				lowercase__   :    int				=			text_classifier.model
				# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
				lowercase__   :    int				=			'''HuggingFace is in'''
				lowercase__   :    List[Any]				=			text_classifier(_snake_case						)

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

				lowercase__   :    Union[str, Any]				=			['''HuggingFace is in ''', '''Paris is in France''']
				lowercase__   :    Optional[int]				=			text_classifier(_snake_case						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,[{'''label''': ANY(_snake_case						), '''score''': ANY(_snake_case						)}, {'''label''': ANY(_snake_case						), '''score''': ANY(_snake_case						)}]			,)
				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
				lowercase__   :    Dict				=			text_classifier(_snake_case			,top_k=_snake_case						)
				lowercase__   :    List[str]				=			len(model.config.idalabel.values()						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,[[{'''label''': ANY(_snake_case						), '''score''': ANY(_snake_case						)}] * N, [{'''label''': ANY(_snake_case						), '''score''': ANY(_snake_case						)}] * N]			,)

				lowercase__   :    Union[str, Any]				=			{'''text''': '''HuggingFace is in ''', '''text_pair''': '''Paris is in France'''}
				lowercase__   :    Optional[int]				=			text_classifier(_snake_case						)
				self.assertEqual(
				    nested_simplify(_snake_case						)			,{'''label''': ANY(_snake_case						), '''score''': ANY(_snake_case						)}			,)
				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.
				lowercase__   :    List[str]				=			[['''HuggingFace is in ''', '''Paris is in France''']]
				with self.assertRaises(_snake_case						):
						text_classifier(_snake_case						)

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





"""simple docstring"""







from ..utils import DummyObject, requires_backends
class        __A       (	metaclass=A_    ):







		'''simple docstring'''





		lowerCAmelCase			:					List[str]   	=				["torch", "torchsde"]







		def __init__(	self						:  Tuple			,*_snake_case						:  Union[str, Any]			,**_snake_case						:  Any						)					->		Union[str, Any]:






				"""simple docstring"""



				requires_backends(self			,['''torch''', '''torchsde''']						)







		@classmethod
		def 					UpperCAmelCase    (	cls						:  List[str]			,*_snake_case						:  int			,**_snake_case						:  Union[str, Any]						)					->		str:






				"""simple docstring"""



				requires_backends(cls			,['''torch''', '''torchsde''']						)







		@classmethod
		def 					UpperCAmelCase    (	cls						:  List[Any]			,*_snake_case						:  List[Any]			,**_snake_case						:  List[str]						)					->		List[Any]:






				"""simple docstring"""



				requires_backends(cls			,['''torch''', '''torchsde''']						)
