

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


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

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



    @require_torch
    def 					snake_case_			(					self       )						->      Tuple:





           '''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 					snake_case_			(					self       )						->      str:





           '''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 					snake_case_			(					self       )						->      List[Any]:





           '''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 					snake_case_			(					self       )						->      Optional[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 					snake_case_			(					self       )						->      Tuple:





           '''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 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      int:





           '''simple docstring'''
           A_						=      TextClassificationPipeline(model=UpperCamelCase__		,				tokenizer=UpperCamelCase__       )
           return text_classifier, ["HuggingFace is in", "This is another test"]







    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      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()       )



'''simple docstring'''







from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class 					A__      (      _snake_case			):
    lowercase						=		"ClapFeatureExtractor"
    lowercase						=		("RobertaTokenizer", "RobertaTokenizerFast")



    def __init__(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           super().__init__(UpperCamelCase__		,				UpperCamelCase__       )



    def __call__(					self		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				UpperCamelCase__=None		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           A_						=      kwargs.pop("""sampling_rate"""		,				UpperCamelCase__       )

           if text is None and audios is None:
                  raise ValueError("""You have to specify either text or audios. Both cannot be none."""       )

           if text is not None:
                  A_						=      self.tokenizer(UpperCamelCase__		,				return_tensors=UpperCamelCase__		,				**UpperCamelCase__       )

           if audios is not None:
                  A_						=      self.feature_extractor(
                      UpperCamelCase__		,				sampling_rate=UpperCamelCase__		,				return_tensors=UpperCamelCase__		,				**UpperCamelCase__       )

           if text is not None and audios is not None:
                  A_						=      audio_features.input_features
                  return encoding
           elif text is not None:
                  return encoding
           else:
                  return BatchEncoding(data=dict(**UpperCamelCase__       )		,				tensor_type=UpperCamelCase__       )



    def 					snake_case_			(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           return self.tokenizer.batch_decode(*UpperCamelCase__		,				**UpperCamelCase__       )



    def 					snake_case_			(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           return self.tokenizer.decode(*UpperCamelCase__		,				**UpperCamelCase__       )







    @property
    def 					snake_case_			(					self       )						->      int:





           '''simple docstring'''
           A_						=      self.tokenizer.model_input_names
           A_						=      self.feature_extractor.model_input_names
           return list(dict.fromkeys(tokenizer_input_names + feature_extractor_input_names       )       )
