


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


@is_pipeline_test
class      __lowerCAmelCase  (			unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  _SCREAMING_SNAKE_CASE		     =							TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

  if model_mapping is not None:
    _SCREAMING_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:
    _SCREAMING_SNAKE_CASE		     =							{
        config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
    }



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




     """simple docstring"""
     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(_lowerCAmelCase	)     ,					[{"label": "LABEL_0", "score": 0.504}]	)

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

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

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

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

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

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

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



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




     """simple docstring"""
     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(_lowerCAmelCase	)     ,					[{"label": "LABEL_0", "score": 0.504}]	)



  @require_tf
  def        lowerCAmelCase__	(  self							:							str	) ->			int:




     """simple docstring"""
     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(_lowerCAmelCase	)     ,					[{"label": "LABEL_0", "score": 0.504}]	)



  @slow
  @require_torch
  def        lowerCAmelCase__	(  self							:							Dict	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       pipeline("text-classification"	)

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



  @slow
  @require_tf
  def        lowerCAmelCase__	(  self							:							List[str]	) ->			Dict:




     """simple docstring"""
     snake_case_            =       pipeline("text-classification"     ,					framework="tf"	)

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



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							Union[str, Any]	) ->			Optional[Any]:




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



  def        lowerCAmelCase__	(  self							:							str     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							str	) ->			List[str]:




     """simple docstring"""
     snake_case_            =       text_classifier.model
     # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
     snake_case_            =       "HuggingFace is in"
     snake_case_            =       text_classifier(_lowerCAmelCase	)

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

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

     snake_case_            =       {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
     snake_case_            =       text_classifier(_lowerCAmelCase	)
     self.assertEqual(
         nested_simplify(_lowerCAmelCase	)     ,					{"label": ANY(_lowerCAmelCase	), "score": ANY(_lowerCAmelCase	)}     ,					)
     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(_lowerCAmelCase	):
        text_classifier(_lowerCAmelCase	)

     # 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(_lowerCAmelCase	)     ,					[{"label": ANY(_lowerCAmelCase	), "score": ANY(_lowerCAmelCase	)}]     ,					)
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()	)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE						:str			=  {'''configuration_unispeech''': ['''UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechConfig''']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   SCREAMING_SNAKE_CASE						:List[str]			=  [
       '''UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''UniSpeechForCTC''',
       '''UniSpeechForPreTraining''',
       '''UniSpeechForSequenceClassification''',
       '''UniSpeechModel''',
       '''UniSpeechPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_unispeech import (
          UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST,
          UniSpeechForCTC,
          UniSpeechForPreTraining,
          UniSpeechForSequenceClassification,
          UniSpeechModel,
          UniSpeechPreTrainedModel,
      )

else:
   import sys

   SCREAMING_SNAKE_CASE						:List[str]			=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




