






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






@is_pipeline_test
class 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




      __snake_case       =  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
      __snake_case       =  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







      @require_torch
      def       __lowerCAmelCase					(      self      :						str  )    ->List[Any]:




       """simple docstring"""


       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      :						Dict  )    ->Any:




       """simple docstring"""


       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      :						List[str]  )    ->Dict:




       """simple docstring"""


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




       """simple docstring"""


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




       """simple docstring"""


       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      :						Union[str, Any] ,					__UpperCAmelCase      :						List[Any] ,					__UpperCAmelCase      :						Optional[Any] ,					__UpperCAmelCase      :						Tuple  )    ->str:




       """simple docstring"""


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







      def       __lowerCAmelCase					(      self      :						Any ,					__UpperCAmelCase      :						Optional[Any] ,					__UpperCAmelCase      :						str  )    ->Optional[Any]:




       """simple docstring"""


       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()  )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__				   =		{
    "configuration_nllb_moe": [
        "NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "NllbMoeConfig",
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__				   =		[
         "NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST",
         "NllbMoeForConditionalGeneration",
         "NllbMoeModel",
         "NllbMoePreTrainedModel",
         "NllbMoeTop2Router",
         "NllbMoeSparseMLP",
     ]


if TYPE_CHECKING:
     from .configuration_nllb_moe import (
         NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
         NllbMoeConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_nllb_moe import (
              NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
              NllbMoeForConditionalGeneration,
              NllbMoeModel,
              NllbMoePreTrainedModel,
              NllbMoeSparseMLP,
              NllbMoeTopaRouter,
          )


else:
     import sys

     UpperCAmelCase__				   =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


