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



@is_pipeline_test
class 						UpperCamelCase__    (			unittest.TestCase       ):
   _SCREAMING_SNAKE_CASE :				List[str]      			= MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
   _SCREAMING_SNAKE_CASE :				str      			= TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

   if model_mapping is not None:
      _SCREAMING_SNAKE_CASE :				int      			= {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  lowerCAmelCase     (self					:   List[Any]  ):
    __a					:    Dict													=    pipeline(
        task='''text-classification'''   ,							model='''hf-internal-testing/tiny-random-distilbert'''   ,							framework='''pt'''  )

    __a					:    int													=    text_classifier('''This is great !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''LABEL_0''', '''score''': 0.504}]  )

    __a					:    int													=    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					:    Dict													=    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					:    Optional[Any]													=    text_classifier('''This is great !'''   ,							top_k=1  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''LABEL_0''', '''score''': 0.504}]  )

    # Legacy behavior
    __a					:    Tuple													=    text_classifier('''This is great !'''   ,							return_all_scores=UpperCamelCase__  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''LABEL_0''', '''score''': 0.504}]  )

    __a					:    Any													=    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					:    str													=    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					:    str													=    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  lowerCAmelCase     (self					:   Optional[Any]  ):
    import torch

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

    __a					:    int													=    text_classifier('''This is great !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''LABEL_0''', '''score''': 0.504}]  )
   @require_tf
   def  lowerCAmelCase     (self					:   Optional[Any]  ):
    __a					:    Any													=    pipeline(
        task='''text-classification'''   ,							model='''hf-internal-testing/tiny-random-distilbert'''   ,							framework='''tf'''  )

    __a					:    Dict													=    text_classifier('''This is great !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''LABEL_0''', '''score''': 0.504}]  )
   @slow
   @require_torch
   def  lowerCAmelCase     (self					:   int  ):
    __a					:    int													=    pipeline('''text-classification'''  )

    __a					:    List[str]													=    text_classifier('''This is great !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''POSITIVE''', '''score''': 1.0}]  )
    __a					:    Any													=    text_classifier('''This is bad !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''NEGATIVE''', '''score''': 1.0}]  )
    __a					:    Union[str, Any]													=    text_classifier('''Birds are a type of animal'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''POSITIVE''', '''score''': 0.988}]  )
   @slow
   @require_tf
   def  lowerCAmelCase     (self					:   List[str]  ):
    __a					:    Optional[int]													=    pipeline('''text-classification'''   ,							framework='''tf'''  )

    __a					:    List[str]													=    text_classifier('''This is great !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''POSITIVE''', '''score''': 1.0}]  )
    __a					:    Tuple													=    text_classifier('''This is bad !'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''NEGATIVE''', '''score''': 1.0}]  )
    __a					:    Optional[Any]													=    text_classifier('''Birds are a type of animal'''  )
    self.assertEqual(nested_simplify(UpperCamelCase__  )   ,							[{'''label''': '''POSITIVE''', '''score''': 0.988}]  )
   def  lowerCAmelCase     (self					:   int   ,							snake_case_					:   str   ,							snake_case_					:   Optional[int]   ,							snake_case_					:   Tuple  ):
    __a					:    Dict													=    TextClassificationPipeline(model=UpperCamelCase__   ,							tokenizer=UpperCamelCase__  )
    return text_classifier, ["HuggingFace is in", "This is another test"]







   def  lowerCAmelCase     (self					:   Union[str, Any]   ,							snake_case_					:   int   ,							snake_case_					:   Union[str, Any]  ):
    __a					:    Optional[Any]													=    text_classifier.model
    # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
    __a					:    Optional[Any]													=    "HuggingFace is in"
    __a					:    Optional[Any]													=    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					:    Optional[int]													=    ["HuggingFace is in ", "Paris is in France"]
    __a					:    List[Any]													=    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					:    List[str]													=    text_classifier(UpperCamelCase__   ,							top_k=UpperCamelCase__  )
    __a					:    List[str]													=    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					:    Tuple													=    {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
    __a					:    str													=    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					:    List[Any]													=    [["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					:    Dict													=    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 collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
  from ...onnx.config import PatchingSpec
  from ...tokenization_utils_base import PreTrainedTokenizerBase


__snake_case       =       logging.get_logger(__name__)

__snake_case       =       {
    """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json""",
    """allenai/longformer-large-4096""": """https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json""",
    """allenai/longformer-large-4096-finetuned-triviaqa""": (
        """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json"""
    ),
    """allenai/longformer-base-4096-extra.pos.embd.only""": (
        """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json"""
    ),
    """allenai/longformer-large-4096-extra.pos.embd.only""": (
        """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json"""
    ),
}







class _lowerCAmelCase							( snake_case_      ):
   __UpperCAmelCase					:			Tuple				    =    '''longformer'''







   def __init__(      self		,      UpperCamelCase__ = 512		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 1		,      UpperCamelCase__ = 0		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 3_0522		,      UpperCamelCase__ = 768		,      UpperCamelCase__ = 12		,      UpperCamelCase__ = 12		,      UpperCamelCase__ = 3072		,      UpperCamelCase__ = "gelu"		,      UpperCamelCase__ = 0.1		,      UpperCamelCase__ = 0.1		,      UpperCamelCase__ = 512		,      UpperCamelCase__ = 2		,      UpperCamelCase__ = 0.02		,      UpperCamelCase__ = 1e-12		,      UpperCamelCase__ = False		,      **UpperCamelCase__		,      )      ->						str:

       '''simple docstring'''




       super().__init__(pad_token_id=UpperCamelCase__		,      **UpperCamelCase__		)

       snake_case       : int    =       attention_window
       snake_case       : Any    =       sep_token_id
       snake_case       : Dict    =       bos_token_id
       snake_case       : int    =       eos_token_id
       snake_case       : List[str]    =       vocab_size
       snake_case       : Dict    =       hidden_size
       snake_case       : Optional[int]    =       num_hidden_layers
       snake_case       : List[str]    =       num_attention_heads
       snake_case       : Dict    =       hidden_act
       snake_case       : Union[str, Any]    =       intermediate_size
       snake_case       : Optional[int]    =       hidden_dropout_prob
       snake_case       : List[Any]    =       attention_probs_dropout_prob
       snake_case       : Any    =       max_position_embeddings
       snake_case       : Union[str, Any]    =       type_vocab_size
       snake_case       : Union[str, Any]    =       initializer_range
       snake_case       : int    =       layer_norm_eps
       snake_case       : str    =       onnx_export







class _lowerCAmelCase							( snake_case_      ):







   def __init__(      self		,      UpperCamelCase__		,      UpperCamelCase__ = "default"		,      UpperCamelCase__ = None		)      ->						List[str]:

       '''simple docstring'''




       super().__init__(UpperCamelCase__		,      UpperCamelCase__		,      UpperCamelCase__		)
       snake_case       : int    =       True







   @property
   def 					lowerCamelCase						(      self		)      ->						Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       if self.task == "multiple-choice":
           snake_case       : str    =       {0: "batch", 1: "choice", 2: "sequence"}
       else:
           snake_case       : List[str]    =       {0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
               ("global_attention_mask", dynamic_axis),
           ]		)







   @property
   def 					lowerCamelCase						(      self		)      ->						Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       snake_case       : str    =       super().outputs
       if self.task == "default":
           snake_case       : str    =       {0: "batch"}
       return outputs







   @property
   def 					lowerCamelCase						(      self		)      ->						float:

       '''simple docstring'''




       return 1e-4







   @property
   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




       return max(super().default_onnx_opset		,      14		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__ = -1		,      UpperCamelCase__ = -1		,      UpperCamelCase__ = False		,      UpperCamelCase__ = None		,      )      ->						Mapping[str, Any]:

       '''simple docstring'''




       snake_case       : Optional[int]    =       super().generate_dummy_inputs(
           preprocessor=UpperCamelCase__		,      batch_size=UpperCamelCase__		,      seq_length=UpperCamelCase__		,      is_pair=UpperCamelCase__		,      framework=UpperCamelCase__		)
       import torch

       # for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
       # makes the export fail randomly
       snake_case       : Any    =       torch.zeros_like(inputs["input_ids"]		)
       # make every second token global
       snake_case       : Any    =       1

       return inputs





