




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 				a__ ( self    )					->						List[str]:
         UpperCAmelCase_     :				Dict  =     pipeline(
             task='''text-classification'''  ,model='''hf-internal-testing/tiny-random-distilbert'''  ,framework='''pt'''    )

         UpperCAmelCase_     :				Optional[int]  =     text_classifier('''This is great !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}]    )

         UpperCAmelCase_     :				Tuple  =     text_classifier('''This is great !'''  ,top_k=2    )
         self.assertEqual(
             nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}]    )

         UpperCAmelCase_     :				Union[str, Any]  =     text_classifier(['''This is great !''', '''This is bad''']  ,top_k=2    )
         self.assertEqual(
             nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[
                 [{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}],
                 [{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}],
             ]  ,)

         UpperCAmelCase_     :				int  =     text_classifier('''This is great !'''  ,top_k=1    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}]    )

         # Legacy behavior
         UpperCAmelCase_     :				int  =     text_classifier('''This is great !'''  ,return_all_scores=_SCREAMING_SNAKE_CASE    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}]    )

         UpperCAmelCase_     :				Optional[int]  =     text_classifier('''This is great !'''  ,return_all_scores=_SCREAMING_SNAKE_CASE    )
         self.assertEqual(
             nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[[{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}]]    )

         UpperCAmelCase_     :				Any  =     text_classifier(['''This is great !''', '''Something else''']  ,return_all_scores=_SCREAMING_SNAKE_CASE    )
         self.assertEqual(
             nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[
                 [{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}],
                 [{'''label''': '''LABEL_0''', '''score''': 0.5_04}, {'''label''': '''LABEL_1''', '''score''': 0.4_96}],
             ]  ,)

         UpperCAmelCase_     :				Tuple  =     text_classifier(['''This is great !''', '''Something else''']  ,return_all_scores=_SCREAMING_SNAKE_CASE    )
         self.assertEqual(
             nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[
                 {'''label''': '''LABEL_0''', '''score''': 0.5_04},
                 {'''label''': '''LABEL_0''', '''score''': 0.5_04},
             ]  ,)





    @require_torch
    def 				a__ ( self    )					->						str:
         import torch

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

         UpperCAmelCase_     :				Optional[int]  =     text_classifier('''This is great !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}]    )





    @require_tf
    def 				a__ ( self    )					->						Optional[int]:
         UpperCAmelCase_     :				Tuple  =     pipeline(
             task='''text-classification'''  ,model='''hf-internal-testing/tiny-random-distilbert'''  ,framework='''tf'''    )

         UpperCAmelCase_     :				Tuple  =     text_classifier('''This is great !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''LABEL_0''', '''score''': 0.5_04}]    )





    @slow
    @require_torch
    def 				a__ ( self    )					->						Tuple:
         UpperCAmelCase_     :				Union[str, Any]  =     pipeline('''text-classification'''    )

         UpperCAmelCase_     :				Optional[Any]  =     text_classifier('''This is great !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''POSITIVE''', '''score''': 1.0}]    )
         UpperCAmelCase_     :				Tuple  =     text_classifier('''This is bad !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''NEGATIVE''', '''score''': 1.0}]    )
         UpperCAmelCase_     :				Tuple  =     text_classifier('''Birds are a type of animal'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''POSITIVE''', '''score''': 0.9_88}]    )





    @slow
    @require_tf
    def 				a__ ( self    )					->						Union[str, Any]:
         UpperCAmelCase_     :				Union[str, Any]  =     pipeline('''text-classification'''  ,framework='''tf'''    )

         UpperCAmelCase_     :				List[Any]  =     text_classifier('''This is great !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''POSITIVE''', '''score''': 1.0}]    )
         UpperCAmelCase_     :				Any  =     text_classifier('''This is bad !'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''NEGATIVE''', '''score''': 1.0}]    )
         UpperCAmelCase_     :				Optional[Any]  =     text_classifier('''Birds are a type of animal'''    )
         self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE    )  ,[{'''label''': '''POSITIVE''', '''score''': 0.9_88}]    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )					->						int:
         UpperCAmelCase_     :				Optional[int]  =     TextClassificationPipeline(model=_SCREAMING_SNAKE_CASE  ,tokenizer=_SCREAMING_SNAKE_CASE    )
         return text_classifier, ["HuggingFace is in", "This is another test"]





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )					->						Optional[Any]:
         UpperCAmelCase_     :				Tuple  =     text_classifier.model
         # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
         UpperCAmelCase_     :				Tuple  =     '''HuggingFace is in'''
         UpperCAmelCase_     :				str  =     text_classifier(_SCREAMING_SNAKE_CASE    )

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

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

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

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





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


__a							     =					{}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					['NllbTokenizer']

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					['NllbTokenizerFast']


if TYPE_CHECKING:
     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_nllb import NllbTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_nllb_fast import NllbTokenizerFast

else:
     import sys

     __a							     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)