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


@is_pipeline_test
class A_	(unittest.TestCase      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						int       =		MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  SCREAMING_SNAKE_CASE__			:						Optional[Any]       =		TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

  if model_mapping is not None:
    SCREAMING_SNAKE_CASE__			:						List[Any]       =		{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__			:						int       =		{
        config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
    }







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="pt"  )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

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

     UpperCAmelCase_					:					int			     =    text_classifier(["This is great !", "This is bad"]				,   top_k=2  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             [{"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}],
         ]				,   )

     UpperCAmelCase_					:					List[Any]			     =    text_classifier("This is great !"				,   top_k=1  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     # Legacy behavior
     UpperCAmelCase_					:					Union[str, Any]			     =    text_classifier("This is great !"				,   return_all_scores=lowercase_  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("This is great !"				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]]  )

     UpperCAmelCase_					:					Optional[int]			     =    text_classifier(["This is great !", "Something else"]				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             [{"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}],
         ]				,   )

     UpperCAmelCase_					:					Optional[int]			     =    text_classifier(["This is great !", "Something else"]				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             {"label": "LABEL_0", "score": 0.5_04},
             {"label": "LABEL_0", "score": 0.5_04},
         ]				,   )







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     import torch

     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="pt"				,   device=torch.device("cpu"  )				,   )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )







  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="tf"  )

     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )







  @slow
  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    pipeline("text-classification"  )

     UpperCAmelCase_					:					Tuple			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					int			     =    text_classifier("This is bad !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "NEGATIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("Birds are a type of animal"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 0.9_88}]  )







  @slow
  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    pipeline("text-classification"				,   framework="tf"  )

     UpperCAmelCase_					:					int			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					List[Any]			     =    text_classifier("This is bad !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "NEGATIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					Union[str, Any]			     =    text_classifier("Birds are a type of animal"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 0.9_88}]  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    TextClassificationPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     return text_classifier, ["HuggingFace is in", "This is another test"]







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    text_classifier.model
     # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
     UpperCAmelCase_					:					str			     =    "HuggingFace is in"
     UpperCAmelCase_					:					Dict			     =    text_classifier(lowercase_  )

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

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

     UpperCAmelCase_					:					List[Any]			     =    {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
     UpperCAmelCase_					:					int			     =    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.
     UpperCAmelCase_					:					Dict			     =    [["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
     UpperCAmelCase_					:					Optional[int]			     =    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 TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__  :  str						     =	{
    'configuration_mctct': ['MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MCTCTConfig'],
    'feature_extraction_mctct': ['MCTCTFeatureExtractor'],
    'processing_mctct': ['MCTCTProcessor'],
}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__  :  Any						     =	[
						    'MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'MCTCTForCTC',
						    'MCTCTModel',
						    'MCTCTPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
						from .feature_extraction_mctct import MCTCTFeatureExtractor
						from .processing_mctct import MCTCTProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
						import sys

						lowerCAmelCase__  :  Any						     =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



