



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


@is_pipeline_test
class    SCREAMING_SNAKE_CASE__ (							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 					_UpperCAmelCase	(				self			:				Optional[int]):







      """simple docstring"""







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

      lowercase_								= text_classifier("""This is great !""")
      self.assertEqual(nested_simplify(lowercase__) ,  [{"""label""": """LABEL_0""", """score""": 0.504}])

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

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

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

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

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

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

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

    @require_torch
    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      import torch

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

      lowercase_								= text_classifier("""This is great !""")
      self.assertEqual(nested_simplify(lowercase__) ,  [{"""label""": """LABEL_0""", """score""": 0.504}])

    @require_tf
    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







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

      lowercase_								= text_classifier("""This is great !""")
      self.assertEqual(nested_simplify(lowercase__) ,  [{"""label""": """LABEL_0""", """score""": 0.504}])

    @slow
    @require_torch
    def 					_UpperCAmelCase	(				self			:				Optional[int]):







      """simple docstring"""







      lowercase_								= pipeline("""text-classification""")

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

    @slow
    @require_tf
    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= pipeline("""text-classification""" ,  framework="""tf""")

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

    def 					_UpperCAmelCase	(				self			:				int ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				str):







      """simple docstring"""







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




    def 					_UpperCAmelCase	(				self			:				int ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Tuple):







      """simple docstring"""







      lowercase_								= text_classifier.model
      # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
      lowercase_								= """HuggingFace is in"""
      lowercase_								= text_classifier(lowercase__)

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

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

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

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






"""simple docstring"""
from typing import List

import datasets
from datasets.tasks import AudioClassification

from ..folder_based_builder import folder_based_builder


UpperCAmelCase						:		Union[str, Any]			= datasets.utils.logging.get_logger(__name__)


class    SCREAMING_SNAKE_CASE__ (							folder_based_builder.FolderBasedBuilderConfig   ):
    lowercase__      =   None
    lowercase__      =   None







class    SCREAMING_SNAKE_CASE__ (							folder_based_builder.FolderBasedBuilder   ):
    lowercase__      =   datasets.Audio()
    lowercase__      =   "audio"
    lowercase__      =   AudioFolderConfig
    lowercase__      =   42  # definition at the bottom of the script
    lowercase__      =   AudioClassification(audio_column="audio"      ,  label_column="label"   )







UpperCAmelCase						:		Tuple			= [
    ".aiff",
    ".au",
    ".avr",
    ".caf",
    ".flac",
    ".htk",
    ".svx",
    ".mat4",
    ".mat5",
    ".mpc2k",
    ".ogg",
    ".paf",
    ".pvf",
    ".raw",
    ".rf64",
    ".sd2",
    ".sds",
    ".ircam",
    ".voc",
    ".w64",
    ".wav",
    ".nist",
    ".wavex",
    ".wve",
    ".xi",
    ".mp3",
    ".opus",
]
UpperCAmelCase						:		Any			= AUDIO_EXTENSIONS

