
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 							lowerCAmelCase_						(    unittest.TestCase							):




			'''simple docstring'''


			_lowercase      =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			_lowercase      =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







			@require_torch
			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=pipeline(
										    task='text-classification'    ,							model='hf-internal-testing/tiny-random-distilbert'    ,							framework='pt'  )

										SCREAMING_SNAKE_CASE_	:							Dict											=text_classifier('This is great !'  )
										self.assertEqual(nested_simplify(lowerCamelCase__  )    ,							[{'label': 'LABEL_0', 'score': 0.504}]  )

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

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

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

										# Legacy behavior
										SCREAMING_SNAKE_CASE_	:							List[Any]											=text_classifier('This is great !'    ,							return_all_scores=lowerCamelCase__  )
										self.assertEqual(nested_simplify(lowerCamelCase__  )    ,							[{'label': 'LABEL_0', 'score': 0.504}]  )

										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=text_classifier('This is great !'    ,							return_all_scores=lowerCamelCase__  )
										self.assertEqual(
										    nested_simplify(lowerCamelCase__  )    ,							[[{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}]]  )

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

										SCREAMING_SNAKE_CASE_	:							Union[str, Any]											=text_classifier(['This is great !', 'Something else']    ,							return_all_scores=lowerCamelCase__  )
										self.assertEqual(
										    nested_simplify(lowerCamelCase__  )    ,							[
										        {'label': 'LABEL_0', 'score': 0.504},
										        {'label': 'LABEL_0', 'score': 0.504},
										    ]    ,							)







			@require_torch
			def      __lowerCamelCase    (	self  ):
										import torch

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

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







			@require_tf
			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							int											=pipeline(
										    task='text-classification'    ,							model='hf-internal-testing/tiny-random-distilbert'    ,							framework='tf'  )

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







			@slow
			@require_torch
			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							List[str]											=pipeline('text-classification'  )

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







			@slow
			@require_tf
			def      __lowerCamelCase    (	self  ):
										SCREAMING_SNAKE_CASE_	:							Dict											=pipeline('text-classification'    ,							framework='tf'  )

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







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							Dict											=TextClassificationPipeline(model=lowerCamelCase__    ,							tokenizer=lowerCamelCase__  )
										return text_classifier, ["HuggingFace is in", "This is another test"]







			def      __lowerCamelCase    (	self    ,							__UpperCAmelCase    ,							__UpperCAmelCase  ):
										SCREAMING_SNAKE_CASE_	:							Tuple											=text_classifier.model
										# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
										SCREAMING_SNAKE_CASE_	:							Any											='HuggingFace is in'
										SCREAMING_SNAKE_CASE_	:							Optional[int]											=text_classifier(lowerCamelCase__  )

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

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

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

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








def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      return int((input_a, input_a).count(0   ) != 0   )







def 							_lowerCamelCase   (			):
      '''simple docstring'''







      assert nand_gate(0		,				0   ) == 1
      assert nand_gate(0		,				1   ) == 1
      assert nand_gate(1		,				0   ) == 1
      assert nand_gate(1		,				1   ) == 0


if __name__ == "__main__":
      print(nand_gate(0, 0))
      print(nand_gate(0, 1))
      print(nand_gate(1, 0))
      print(nand_gate(1, 1))





