





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.
_snake_case           =			{"""LayoutLMv2Config""", """LayoutLMv3Config"""}





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

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







  @require_torch
  def   UpperCAmelCase					(      self  :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(__UpperCAmelCase )   ,							[{"label": "LABEL_0", "score": 0.504}] )

     lowercase__			       =  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}] )

     lowercase__			       =  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}],
         ]   ,							)

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

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

     lowercase__			       =  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}]] )

     lowercase__			       =  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}],
         ]   ,							)

     lowercase__			       =  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   UpperCAmelCase					(      self  :Dict ):






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







  @slow
  @require_torch
  def   UpperCAmelCase					(      self  :str ):






     '''simple docstring'''





     lowercase__			       =  pipeline("text-classification" )

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







  @slow
  @require_tf
  def   UpperCAmelCase					(      self  :Union[str, Any] ):






     '''simple docstring'''





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

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







  def   UpperCAmelCase					(      self  :Any   ,							_lowercase  :Any   ,							_lowercase  :List[Any]   ,							_lowercase  :Optional[int] ):






     '''simple docstring'''





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







  def   UpperCAmelCase					(      self  :List[Any]   ,							_lowercase  :Tuple   ,							_lowercase  :List[Any] ):






     '''simple docstring'''





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

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

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

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













from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_snake_case           =			{
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case           =			[
      """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """AutoformerForPrediction""",
      """AutoformerModel""",
      """AutoformerPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_autoformer import (
      AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      AutoformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_autoformer import (
        AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        AutoformerForPrediction,
        AutoformerModel,
        AutoformerPreTrainedModel,
    )

else:
  import sys

  _snake_case           =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






