




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.
UpperCamelCase__ :   str						=							{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}







@is_pipeline_test
class 				lowerCAmelCase_       (					unittest.TestCase							):
				__a     :       Dict						=     MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
				__a     :       List[Any]						=     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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






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

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

							SCREAMING_SNAKE_CASE_   : 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}] )

							SCREAMING_SNAKE_CASE_   : 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}],
							    ]      ,)

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

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

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      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}]] )

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      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}],
							    ]      ,)

							SCREAMING_SNAKE_CASE_   : Tuple					  =      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 		snake_case	(			self ):
							import torch

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

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






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

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






				@slow
				@require_torch
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      pipeline('text-classification' )

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






				@slow
				@require_tf
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      pipeline('text-classification'      ,framework='tf' )

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






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      TextClassificationPipeline(model=snake_case__      ,tokenizer=snake_case__ )
							return text_classifier, ["HuggingFace is in", "This is another test"]






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      text_classifier.model
							# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
							SCREAMING_SNAKE_CASE_   : Dict					  =      'HuggingFace is in'
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      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() )

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      ['HuggingFace is in ', 'Paris is in France']
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      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
							SCREAMING_SNAKE_CASE_   : Tuple					  =      text_classifier(snake_case__      ,top_k=snake_case__ )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      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]      ,)

							SCREAMING_SNAKE_CASE_   : List[str]					  =      {'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      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.
							SCREAMING_SNAKE_CASE_   : 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
							SCREAMING_SNAKE_CASE_   : Tuple					  =      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"""




import doctest
from collections import deque

import numpy as np





class 			snake_case  :

							def __init__(self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			[2, 1, 2, -1]
									SCREAMING_SNAKE_CASE_    			=			[1, 2, 3, 4]







							def _lowercase       (self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			len(self.first_signal     )
									SCREAMING_SNAKE_CASE_    			=			len(self.second_signal     )

									SCREAMING_SNAKE_CASE_    			=			max(SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     )

									# create a zero matrix of max_length x max_length
									SCREAMING_SNAKE_CASE_    			=			[[0] * max_length for i in range(SCREAMING_SNAKE_CASE_     )]

									# fills the smaller signal with zeros to make both signals of same length
									if length_first_signal < length_second_signal:
											self.first_signal += [0] * (max_length - length_first_signal)
									elif length_first_signal > length_second_signal:
											self.second_signal += [0] * (max_length - length_second_signal)
									for i in range(SCREAMING_SNAKE_CASE_     ):
											SCREAMING_SNAKE_CASE_    			=			deque(self.second_signal     )
											rotated_signal.rotate(SCREAMING_SNAKE_CASE_     )
											for j, item in enumerate(SCREAMING_SNAKE_CASE_     ):
													matrix[i][j] += item

        # multiply the matrix with the first signal
									SCREAMING_SNAKE_CASE_    			=			np.matmul(np.transpose(SCREAMING_SNAKE_CASE_     )							,							np.transpose(self.first_signal     )     )

									# rounding-off to two decimal places
									return [round(SCREAMING_SNAKE_CASE_							,							2     ) for i in final_signal]


if __name__ == "__main__":
						doctest.testmod()