



import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SPIECE_UNDERLINE, is_sentencepiece_available
from transformers.models.speech_to_text import SpeechaTextTokenizer
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase	       =	get_tests_dir('''fixtures/test_sentencepiece.model''')

if is_sentencepiece_available():
    import sentencepiece as sp


__UpperCAmelCase	       =	5
__UpperCAmelCase	       =	10



@require_sentencepiece
@require_tokenizers
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Dict       					=  SpeechaTextTokenizer
       UpperCAmelCase__    : Optional[int]       					=  False
       UpperCAmelCase__    : Union[str, Any]       					=  True
       def  snake_case_	(      self	)					->		Optional[int]:
          super().setUp()

          UpperCamelCase   :  Any						     =     sp.SentencePieceProcessor()
          spm_model.Load(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Optional[Any]						     =     ['<s>', '<pad>', '</s>', '<unk>']

          vocab += [spm_model.IdToPiece(id_	) for id_ in range(len(SCREAMING_SNAKE_CASE_	)	)]
          UpperCamelCase   :  Tuple						     =     dict(zip(SCREAMING_SNAKE_CASE_,      range(len(SCREAMING_SNAKE_CASE_	)	)	)	)

          UpperCamelCase   :  Any						     =     Path(self.tmpdirname	)
          save_json(SCREAMING_SNAKE_CASE_,      save_dir / VOCAB_FILES_NAMES['vocab_file']	)
          if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
             copyfile(SCREAMING_SNAKE_CASE_,      save_dir / VOCAB_FILES_NAMES['spm_file']	)

          UpperCamelCase   :  Union[str, Any]						     =     SpeechaTextTokenizer.from_pretrained(self.tmpdirname	)
          tokenizer.save_pretrained(self.tmpdirname	)
       def  snake_case_	(      self	)					->		List[Any]:
          UpperCamelCase   :  Union[str, Any]						     =     '<pad>'
          UpperCamelCase   :  Dict						     =     1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(SCREAMING_SNAKE_CASE_	),      SCREAMING_SNAKE_CASE_	)
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(SCREAMING_SNAKE_CASE_	),      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		str:
          UpperCamelCase   :  Any						     =     list(self.get_tokenizer().get_vocab().keys()	)

          self.assertEqual(vocab_keys[0],      '<s>'	)
          self.assertEqual(vocab_keys[1],      '<pad>'	)
          self.assertEqual(vocab_keys[-1],      'j'	)
          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      1001	)
       def  snake_case_	(      self	)					->		List[Any]:
          self.assertEqual(self.get_tokenizer().vocab_size,      1001	)
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  Optional[Any]						     =     SpeechaTextTokenizer.from_pretrained(self.tmpdirname	)

          UpperCamelCase   :  Optional[int]						     =     tokenizer.tokenize('This is a test'	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      ['▁This', '▁is', '▁a', '▁t', 'est']	)

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_	),      [289, 50, 14, 174, 386],      )

          UpperCamelCase   :  Tuple						     =     tokenizer.tokenize('I was born in 92000, and this is falsé.'	)
          self.assertListEqual(
              SCREAMING_SNAKE_CASE_,      [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.'],      )
          UpperCamelCase   :  Optional[int]						     =     tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      [12, 25, 88, 59, 28, 23, 11, 4, 606, 351, 351, 351, 7, 16, 70, 50, 76, 84, 10, 4, 8]	)

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(
              SCREAMING_SNAKE_CASE_,      [SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.'],      )






       @slow
       def  snake_case_	(      self	)					->		List[Any]:
          # fmt: off
          UpperCamelCase   :  int						     =     {'input_ids': [[3791, 797, 31, 11, 64, 797, 31, 2429, 433, 12, 1176, 12, 20, 786, 915, 142, 2413, 240, 37, 3238, 797, 31, 11, 35, 93, 915, 142, 2413, 240, 37, 5540, 567, 1276, 93, 37, 610, 40, 62, 455, 657, 1042, 123, 780, 177, 37, 309, 241, 1298, 514, 20, 292, 2737, 114, 2469, 241, 85, 64, 302, 548, 528, 423, 4, 509, 406, 423, 37, 601, 4, 777, 302, 548, 528, 423, 284, 4, 3388, 511, 459, 4, 3555, 40, 321, 302, 705, 4, 3388, 511, 583, 326, 5, 5, 5, 62, 3310, 560, 177, 2680, 217, 1508, 32, 31, 853, 418, 64, 583, 511, 1605, 62, 35, 93, 560, 177, 2680, 217, 1508, 1521, 64, 583, 511, 519, 62, 20, 1515, 764, 20, 149, 261, 5625, 7972, 20, 5540, 567, 1276, 93, 3925, 1675, 11, 15, 802, 7972, 576, 217, 1508, 11, 35, 93, 1253, 2441, 15, 289, 652, 31, 416, 321, 3842, 115, 40, 911, 8, 476, 619, 4, 380, 142, 423, 335, 240, 35, 93, 264, 8, 11, 335, 569, 420, 163, 5, 2], [260, 548, 528, 423, 20, 451, 20, 2681, 1153, 3434, 20, 5540, 37, 567, 126, 1253, 2441, 3376, 449, 210, 431, 1563, 177, 767, 5540, 11, 1203, 472, 11, 2953, 685, 285, 364, 706, 1153, 20, 6799, 20, 2869, 20, 4464, 126, 40, 2429, 20, 1040, 866, 2664, 418, 20, 318, 20, 1726, 186, 20, 265, 522, 35, 93, 2191, 4634, 20, 1040, 12, 6799, 15, 228, 2356, 142, 31, 11, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2575, 2666, 684, 1582, 1176, 12, 627, 149, 619, 20, 4902, 563, 11, 20, 149, 261, 3420, 2356, 174, 142, 4714, 131, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=SCREAMING_SNAKE_CASE_,      model_name='facebook/s2t-small-mustc-en-de-st',      revision='a14f04cf0776c02f62a8cb800cf7909e15ea23ad',      )






@require_sentencepiece
class     lowerCAmelCase_		(  unittest.TestCase							):
       UpperCAmelCase__    : int       					=  "valhalla/s2t_mustc_multilinguial_medium"

       UpperCAmelCase__    : int       					=  "C'est trop cool"
       UpperCAmelCase__    : List[str]       					=  "Esto es genial"
       @classmethod
       def  snake_case_	(      cls	)					->		List[str]:
          UpperCamelCase   :  SpeechaTextTokenizer						     =     SpeechaTextTokenizer.from_pretrained(cls.checkpoint_name	)
          return cls
       def  snake_case_	(      self	)					->		Optional[Any]:
          self.assertEqual(self.tokenizer.lang_code_to_id['pt'],      4	)
          self.assertEqual(self.tokenizer.lang_code_to_id['ru'],      6	)
          self.assertEqual(self.tokenizer.lang_code_to_id['it'],      9	)
          self.assertEqual(self.tokenizer.lang_code_to_id['de'],      11	)
       def  snake_case_	(      self	)					->		str:
          self.assertEqual(self.tokenizer.vocab_size,      1_0000	)
       def  snake_case_	(      self	)					->		str:
          self.assertIn(SCREAMING_SNAKE_CASE_,      self.tokenizer.all_special_ids	)
          UpperCamelCase   :  int						     =     [ES_CODE, 4, 1601, 47, 7647, 2]
          UpperCamelCase   :  List[Any]						     =     self.tokenizer.decode(SCREAMING_SNAKE_CASE_,      skip_special_tokens=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  str						     =     self.tokenizer.decode(generated_ids[1:],      skip_special_tokens=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          self.assertNotIn(self.tokenizer.eos_token,      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  List[str]						     =     'fr'
          UpperCamelCase   :  Dict						     =     self.tokenizer(self.french_text	).input_ids
          self.assertEqual(encoded[0],      SCREAMING_SNAKE_CASE_	)
          self.assertEqual(encoded[-1],      self.tokenizer.eos_token_id	)






       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  int						     =     'fr'
          self.assertListEqual(self.tokenizer.prefix_tokens,      [FR_CODE]	)

          UpperCamelCase   :  Tuple						     =     'es'
          self.assertListEqual(self.tokenizer.prefix_tokens,      [ES_CODE]	)








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



@is_pipeline_test
class     lowerCAmelCase_		(  unittest.TestCase							):
       UpperCAmelCase__    : Dict       					=  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       UpperCAmelCase__    : List[str]       					=  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

       if model_mapping is not None:
              UpperCAmelCase__    : Optional[Any]       					=  {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
       if tf_model_mapping is not None:
              UpperCAmelCase__    : Dict       					=  {
                  config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
              }
       @require_torch
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  List[str]						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='pt'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

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

          UpperCamelCase   :  List[Any]						     =     text_classifier(['This is great !', 'This is bad'],      top_k=2	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  [{'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(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

          # Legacy behavior
          UpperCamelCase   :  str						     =     text_classifier('This is great !',      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)

          UpperCamelCase   :  Tuple						     =     text_classifier('This is great !',      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [[{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}]]	)

          UpperCamelCase   :  List[Any]						     =     text_classifier(['This is great !', 'Something else'],      return_all_scores=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  [{'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=SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      [
                  {'label': 'LABEL_0', 'score': 0.5_04},
                  {'label': 'LABEL_0', 'score': 0.5_04},
              ],      )
       @require_torch
       def  snake_case_	(      self	)					->		Optional[Any]:
          import torch

          UpperCamelCase   :  str						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='pt',      device=torch.device('cpu'	),      )

          UpperCamelCase   :  List[Any]						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)
       @require_tf
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  List[Any]						     =     pipeline(
              task='text-classification',      model='hf-internal-testing/tiny-random-distilbert',      framework='tf'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'LABEL_0', 'score': 0.5_04}]	)
       @slow
       @require_torch
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  str						     =     pipeline('text-classification'	)

          UpperCamelCase   :  str						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 1.0}]	)
          UpperCamelCase   :  List[str]						     =     text_classifier('This is bad !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'NEGATIVE', 'score': 1.0}]	)
          UpperCamelCase   :  int						     =     text_classifier('Birds are a type of animal'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 0.9_88}]	)
       @slow
       @require_tf
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  int						     =     pipeline('text-classification',      framework='tf'	)

          UpperCamelCase   :  Tuple						     =     text_classifier('This is great !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 1.0}]	)
          UpperCamelCase   :  Union[str, Any]						     =     text_classifier('This is bad !'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'NEGATIVE', 'score': 1.0}]	)
          UpperCamelCase   :  int						     =     text_classifier('Birds are a type of animal'	)
          self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_	),      [{'label': 'POSITIVE', 'score': 0.9_88}]	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Union[str, Any]:
          UpperCamelCase   :  str						     =     TextClassificationPipeline(model=SCREAMING_SNAKE_CASE_,      tokenizer=SCREAMING_SNAKE_CASE_	)
          return text_classifier, ["HuggingFace is in", "This is another test"]






       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Any:
          UpperCamelCase   :  List[str]						     =     text_classifier.model
          # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
          UpperCamelCase   :  List[str]						     =     'HuggingFace is in'
          UpperCamelCase   :  Tuple						     =     text_classifier(SCREAMING_SNAKE_CASE_	)

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

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

          UpperCamelCase   :  str						     =     {'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
          UpperCamelCase   :  Union[str, Any]						     =     text_classifier(SCREAMING_SNAKE_CASE_	)
          self.assertEqual(
              nested_simplify(SCREAMING_SNAKE_CASE_	),      {'label': ANY(SCREAMING_SNAKE_CASE_	), 'score': ANY(SCREAMING_SNAKE_CASE_	)},      )
          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   :  List[str]						     =     [['HuggingFace is in ', 'Paris is in France']]
          with self.assertRaises(SCREAMING_SNAKE_CASE_	):
             text_classifier(SCREAMING_SNAKE_CASE_	)

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



