





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.
lowercase    : Optional[Any]    	=  {"""LayoutLMv2Config""", """LayoutLMv3Config"""}

@is_pipeline_test
class  __A(						unittest.TestCase ):
     __A	  =       MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
     __A	  =       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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

     @require_torch
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

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

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

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

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

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

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

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

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

            _UpperCamelCase              =						text_classifier(['''This is great !''', '''Something else'''],       return_all_scores=A      )
            self.assertEqual(
                nested_simplify(A      ),       [
                    {'''label''': '''LABEL_0''', '''score''': 0.504},
                    {'''label''': '''LABEL_0''', '''score''': 0.504},
                ],       )

     @require_torch
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            import torch

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

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

     @require_tf
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

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

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

     @slow
     @require_torch
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

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

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

     @slow
     @require_tf
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

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

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

     def 	_UpperCamelCase     (      self,       A,       A,       A      ):





            """simple docstring"""

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



     def 	_UpperCamelCase     (      self,       A,       A      ):





            """simple docstring"""

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

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

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

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

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













def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):
       _UpperCamelCase              =						[]
       if len(lowerCAmelCase					) == 1:
              return [nums.copy()]
       for _ in range(len(lowerCAmelCase					)					):
              _UpperCamelCase              =						nums.pop(0					)
              _UpperCamelCase              =						permute(lowerCAmelCase					)
              for perm in permutations:
                     perm.append(lowerCAmelCase					)
              result.extend(lowerCAmelCase					)
              nums.append(lowerCAmelCase					)
       return result


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):

       def backtrack(lowerCAmelCase					):
              if start == len(lowerCAmelCase					) - 1:
                     output.append(nums[:]					)
              else:
                     for i in range(lowerCAmelCase    ,       len(lowerCAmelCase					)					):
                            _UpperCamelCase       ,		_UpperCamelCase              =						nums[i], nums[start]
                            backtrack(start + 1					)
                            _UpperCamelCase       ,		_UpperCamelCase              =						nums[i], nums[start]  # backtrack

       _UpperCamelCase              =						[]
       backtrack(0					)
       return output


if __name__ == "__main__":
       import doctest

       # use res to print the data in permute2 function
       lowercase    : Optional[Any]    	=  permutea([1, 2, 3])
       print(res)
       doctest.testmod()






