




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





@is_pipeline_test
class 				lowercase_       (     unittest.TestCase							):



 '''simple docstring'''
 UpperCAmelCase    :     Tuple        =	MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 UpperCAmelCase    :     Dict        =	TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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

 @require_torch
 def 			lowerCAmelCase_							( self       :       Dict		):
       _A					   =   pipeline(
           task='text-classification'    ,							model='hf-internal-testing/tiny-random-distilbert'    ,							framework='pt'		)

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

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

       _A					   =   text_classifier(['This is great !', 'This is bad']    ,							top_k=2		)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)    ,							[
               [{'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					   =   text_classifier('This is great !'    ,							top_k=1		)
       self.assertEqual(nested_simplify(_UpperCAmelCase		)    ,							[{'label': 'LABEL_0', 'score': 0.504}]		)

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

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

       _A					   =   text_classifier(['This is great !', 'Something else']    ,							return_all_scores=_UpperCAmelCase		)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)    ,							[
               [{'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					   =   text_classifier(['This is great !', 'Something else']    ,							return_all_scores=_UpperCAmelCase		)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)    ,							[
               {'label': 'LABEL_0', 'score': 0.504},
               {'label': 'LABEL_0', 'score': 0.504},
           ]    ,							)

 @require_torch
 def 			lowerCAmelCase_							( self       :       Optional[Any]		):
       import torch

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

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

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

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

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

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

 @slow
 @require_tf
 def 			lowerCAmelCase_							( self       :       Any		):
       _A					   =   pipeline('text-classification'    ,							framework='tf'		)

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

 def 			lowerCAmelCase_							( self       :       Tuple    ,							_UpperCAmelCase       :       Dict    ,							_UpperCAmelCase       :       Optional[int]    ,							_UpperCAmelCase       :       List[str]		):
       _A					   =   TextClassificationPipeline(model=_UpperCAmelCase    ,							tokenizer=_UpperCAmelCase		)
       return text_classifier, ["HuggingFace is in", "This is another test"]



 def 			lowerCAmelCase_							( self       :       Optional[int]    ,							_UpperCAmelCase       :       Optional[Any]    ,							_UpperCAmelCase       :       Union[str, Any]		):
       _A					   =   text_classifier.model
       # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
       _A					   =   "HuggingFace is in"
       _A					   =   text_classifier(_UpperCAmelCase		)

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

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

       _A					   =   {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
       _A					   =   text_classifier(_UpperCAmelCase		)
       self.assertEqual(
           nested_simplify(_UpperCAmelCase		)    ,							{'label': ANY(_UpperCAmelCase		), 'score': ANY(_UpperCAmelCase		)}    ,							)
       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					   =   [["HuggingFace is in ", "Paris is in France"]]
       with self.assertRaises(_UpperCAmelCase		):
             text_classifier(_UpperCAmelCase		)

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









def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase					,    __lowerCAmelCase			) ->	int:
     while b:
          UpperCamelCase__				,     UpperCamelCase__			:   int       				=  b, a % b
     return a







def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase					,    __lowerCAmelCase			) ->	int:
     return a if b == 0 else euclidean_gcd_recursive(__lowerCAmelCase					,    a % b			)







def 		SCREAMING_SNAKE_CASE							(					) ->	str:
     print(f'euclidean_gcd(3, 5) = {euclidean_gcd(3					,    5			)}'			)
     print(f'euclidean_gcd(5, 3) = {euclidean_gcd(5					,    3			)}'			)
     print(f'euclidean_gcd(1, 3) = {euclidean_gcd(1					,    3			)}'			)
     print(f'euclidean_gcd(3, 6) = {euclidean_gcd(3					,    6			)}'			)
     print(f'euclidean_gcd(6, 3) = {euclidean_gcd(6					,    3			)}'			)

     print(f'euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3					,    5			)}'			)
     print(f'euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5					,    3			)}'			)
     print(f'euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1					,    3			)}'			)
     print(f'euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3					,    6			)}'			)
     print(f'euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6					,    3			)}'			)


if __name__ == "__main__":
 main()