





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.
_a						=   {"LayoutLMv2Config", "LayoutLMv3Config"}






@is_pipeline_test
class       __A					(					unittest.TestCase				):

			'''simple docstring'''







			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 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline(
				    task='''text-classification''' ,						model='''hf-internal-testing/tiny-random-distilbert''' ,						framework='''pt'''							)

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

				lowerCamelCase__              =	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}]							)

				lowerCamelCase__              =	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}],
				    ] ,						)

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

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

				lowerCamelCase__              =	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}]]							)

				lowerCamelCase__              =	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}],
				    ] ,						)

				lowerCamelCase__              =	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							):



				'''simple docstring'''







				import torch

				lowerCamelCase__              =	pipeline(
				    task='''text-classification''' ,						model='''hf-internal-testing/tiny-random-distilbert''' ,						framework='''pt''' ,						device=torch.device('''cpu'''							) ,						)

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





			@require_tf
			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline(
				    task='''text-classification''' ,						model='''hf-internal-testing/tiny-random-distilbert''' ,						framework='''tf'''							)

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





			@slow
			@require_torch
			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline('''text-classification'''							)

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





			@slow
			@require_tf
			def 	__lowerCamelCase       (					self							):



				'''simple docstring'''







				lowerCamelCase__              =	pipeline('''text-classification''' ,						framework='''tf'''							)

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





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	TextClassificationPipeline(model=__lowerCAmelCase ,						tokenizer=__lowerCAmelCase							)
				return text_classifier, ["HuggingFace is in", "This is another test"]





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__              =	text_classifier.model
				# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
				lowerCamelCase__              =	'''HuggingFace is in'''
				lowerCamelCase__              =	text_classifier(__lowerCAmelCase							)

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

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

				lowerCamelCase__              =	{'''text''': '''HuggingFace is in ''', '''text_pair''': '''Paris is in France'''}
				lowerCamelCase__              =	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.
				lowerCamelCase__              =	[['''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
				lowerCamelCase__              =	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()							)










from __future__ import annotations





def lowerCAmelCase__(__snake_case ,__snake_case = None ,__snake_case = None							)       ->   None:







	'''simple docstring'''







	if start is None:
		lowerCamelCase__              =	0

	if end is None:
		lowerCamelCase__              =	len(__snake_case							) - 1

	if start >= end:
		return

	lowerCamelCase__              =	(start + end) // 2

	slowsort(__snake_case ,__snake_case ,__snake_case							)
	slowsort(__snake_case ,mid + 1 ,__snake_case							)

	if sequence[end] < sequence[mid]:
		lowerCamelCase__       ,			lowerCamelCase__              =	sequence[mid], sequence[end]

	slowsort(__snake_case ,__snake_case ,end - 1							)


if __name__ == "__main__":
			from doctest import testmod

			testmod()



