

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







@is_pipeline_test
class 				lowercase       ( unittest.TestCase    ):
    __SCREAMING_SNAKE_CASE      :				Tuple     =    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
    __SCREAMING_SNAKE_CASE      :				List[str]     =    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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




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

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

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

           snake_case_           =					text_classifier(['This is great !', 'This is bad']   ,     top_k=2 )
           self.assertEqual(
               nested_simplify(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}],
               ]   ,     )

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

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

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

           snake_case_           =					text_classifier(['This is great !', 'Something else']   ,     return_all_scores=snake_case )
           self.assertEqual(
               nested_simplify(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}],
               ]   ,     )

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




    @require_torch
    def 					a							(      self ):
           import torch

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

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




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

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




    @slow
    @require_torch
    def 					a							(      self ):
           snake_case_           =					pipeline('text-classification' )

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




    @slow
    @require_tf
    def 					a							(      self ):
           snake_case_           =					pipeline('text-classification'   ,     framework='tf' )

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




    def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
           snake_case_           =					TextClassificationPipeline(model=snake_case   ,     tokenizer=snake_case )
           return text_classifier, ["HuggingFace is in", "This is another test"]




    def 					a							(      self   ,     snake_case   ,     snake_case ):
           snake_case_           =					text_classifier.model
           # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
           snake_case_           =					'HuggingFace is in'
           snake_case_           =					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() )

           snake_case_           =					['HuggingFace is in ', 'Paris is in France']
           snake_case_           =					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
           snake_case_           =					text_classifier(snake_case   ,     top_k=snake_case )
           snake_case_           =					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]   ,     )

           snake_case_           =					{'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
           snake_case_           =					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.
           snake_case_           =					[['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
           snake_case_           =					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() )







# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
from ...utils import deprecate
from ..controlnet.multicontrolnet import MultiControlNetModel  # noqa: F401
from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline  # noqa: F401


deprecate(
    """stable diffusion controlnet""",
    """0.22.0""",
    """Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.""",
    standard_warn=False,
    stacklevel=3,
)




