

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







@is_pipeline_test
class      __lowercase			(    unittest.TestCase					):
		snake_case_				       =       MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
		snake_case_				       =       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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

		@require_torch
		def    __lowercase       (  self		:			List[Any]    ):






			'''simple docstring'''
			UpperCAmelCase__					:  Any					   =					pipeline(
			    task="""text-classification"""					,model="""hf-internal-testing/tiny-random-distilbert"""					,framework="""pt"""    )

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

			UpperCAmelCase__					:  Optional[Any]					   =					text_classifier("""This is great !"""					,top_k=2    )
			self.assertEqual(
			    nested_simplify(lowercase_    )					,[{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}]    )

			UpperCAmelCase__					:  Any					   =					text_classifier(["""This is great !""", """This is bad"""]					,top_k=2    )
			self.assertEqual(
			    nested_simplify(lowercase_    )					,[
			        [{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}],
			        [{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}],
			    ]					,)

			UpperCAmelCase__					:  Optional[int]					   =					text_classifier("""This is great !"""					,top_k=1    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """LABEL_0""", """score""": 0.5_0_4}]    )

			# Legacy behavior
			UpperCAmelCase__					:  Optional[int]					   =					text_classifier("""This is great !"""					,return_all_scores=lowercase_    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """LABEL_0""", """score""": 0.5_0_4}]    )

			UpperCAmelCase__					:  List[str]					   =					text_classifier("""This is great !"""					,return_all_scores=lowercase_    )
			self.assertEqual(
			    nested_simplify(lowercase_    )					,[[{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}]]    )

			UpperCAmelCase__					:  Union[str, Any]					   =					text_classifier(["""This is great !""", """Something else"""]					,return_all_scores=lowercase_    )
			self.assertEqual(
			    nested_simplify(lowercase_    )					,[
			        [{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}],
			        [{"""label""": """LABEL_0""", """score""": 0.5_0_4}, {"""label""": """LABEL_1""", """score""": 0.4_9_6}],
			    ]					,)

			UpperCAmelCase__					:  str					   =					text_classifier(["""This is great !""", """Something else"""]					,return_all_scores=lowercase_    )
			self.assertEqual(
			    nested_simplify(lowercase_    )					,[
			        {"""label""": """LABEL_0""", """score""": 0.5_0_4},
			        {"""label""": """LABEL_0""", """score""": 0.5_0_4},
			    ]					,)

		@require_torch
		def    __lowercase       (  self		:			Dict    ):






			'''simple docstring'''
			import torch

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

			UpperCAmelCase__					:  List[str]					   =					text_classifier("""This is great !"""    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """LABEL_0""", """score""": 0.5_0_4}]    )

		@require_tf
		def    __lowercase       (  self		:			Dict    ):






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

			UpperCAmelCase__					:  List[str]					   =					text_classifier("""This is great !"""    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """LABEL_0""", """score""": 0.5_0_4}]    )

		@slow
		@require_torch
		def    __lowercase       (  self		:			Union[str, Any]    ):






			'''simple docstring'''
			UpperCAmelCase__					:  Tuple					   =					pipeline("""text-classification"""    )

			UpperCAmelCase__					:  Optional[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__					:  str					   =					text_classifier("""Birds are a type of animal"""    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """POSITIVE""", """score""": 0.9_8_8}]    )

		@slow
		@require_tf
		def    __lowercase       (  self		:			Optional[Any]    ):






			'''simple docstring'''
			UpperCAmelCase__					:  List[str]					   =					pipeline("""text-classification"""					,framework="""tf"""    )

			UpperCAmelCase__					:  Optional[int]					   =					text_classifier("""This is great !"""    )
			self.assertEqual(nested_simplify(lowercase_    )					,[{"""label""": """POSITIVE""", """score""": 1.0}]    )
			UpperCAmelCase__					:  Tuple					   =					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_8_8}]    )

		def    __lowercase       (  self		:			Dict					,A		:			List[Any]					,A		:			Union[str, Any]					,A		:			Optional[int]    ):






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




		def    __lowercase       (  self		:			str					,A		:			List[str]					,A		:			Union[str, Any]    ):






			'''simple docstring'''
			UpperCAmelCase__					:  Tuple					   =					text_classifier.model
			# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
			UpperCAmelCase__					:  Optional[Any]					   =					"""HuggingFace is in"""
			UpperCAmelCase__					:  Union[str, Any]					   =					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__					:  int					   =					["""HuggingFace is in """, """Paris is in France"""]
			UpperCAmelCase__					:  int					   =					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__					:  List[Any]					   =					text_classifier(lowercase_					,top_k=lowercase_    )
			UpperCAmelCase__					:  str					   =					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__					:  int					   =					{"""text""": """HuggingFace is in """, """text_pair""": """Paris is in France"""}
			UpperCAmelCase__					:  Optional[Any]					   =					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__					:  Optional[Any]					   =					[["""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[Any]					   =					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_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase =				{
    'configuration_roberta': ['ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RobertaConfig', 'RobertaOnnxConfig'],
    'tokenization_roberta': ['RobertaTokenizer'],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				['RobertaTokenizerFast']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
          'RobertaForCausalLM',
          'RobertaForMaskedLM',
          'RobertaForMultipleChoice',
          'RobertaForQuestionAnswering',
          'RobertaForSequenceClassification',
          'RobertaForTokenClassification',
          'RobertaModel',
          'RobertaPreTrainedModel',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFRobertaForCausalLM',
          'TFRobertaForMaskedLM',
          'TFRobertaForMultipleChoice',
          'TFRobertaForQuestionAnswering',
          'TFRobertaForSequenceClassification',
          'TFRobertaForTokenClassification',
          'TFRobertaMainLayer',
          'TFRobertaModel',
          'TFRobertaPreTrainedModel',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'FlaxRobertaForCausalLM',
          'FlaxRobertaForMaskedLM',
          'FlaxRobertaForMultipleChoice',
          'FlaxRobertaForQuestionAnswering',
          'FlaxRobertaForSequenceClassification',
          'FlaxRobertaForTokenClassification',
          'FlaxRobertaModel',
          'FlaxRobertaPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig, RobertaOnnxConfig
      from .tokenization_roberta import RobertaTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_roberta_fast import RobertaTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_roberta import (
                ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                RobertaForCausalLM,
                RobertaForMaskedLM,
                RobertaForMultipleChoice,
                RobertaForQuestionAnswering,
                RobertaForSequenceClassification,
                RobertaForTokenClassification,
                RobertaModel,
                RobertaPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_roberta import (
                TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFRobertaForCausalLM,
                TFRobertaForMaskedLM,
                TFRobertaForMultipleChoice,
                TFRobertaForQuestionAnswering,
                TFRobertaForSequenceClassification,
                TFRobertaForTokenClassification,
                TFRobertaMainLayer,
                TFRobertaModel,
                TFRobertaPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_roberta import (
                FlaxRobertaForCausalLM,
                FlaxRobertaForMaskedLM,
                FlaxRobertaForMultipleChoice,
                FlaxRobertaForQuestionAnswering,
                FlaxRobertaForSequenceClassification,
                FlaxRobertaForTokenClassification,
                FlaxRobertaModel,
                FlaxRobertaPreTrainedModel,
            )

else:
      import sys

      __UpperCAmelCase =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





