'''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.
_lowercase		:				List[Any]	       =		{"LayoutLMv2Config", "LayoutLMv3Config"}





@is_pipeline_test
class 					__magic_name__		(					unittest.TestCase):
			UpperCamelCase__       = MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			UpperCamelCase__       = TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







			@require_torch
			def 			SCREAMING_SNAKE_CASE_  (			self       :						List[Any]					):
										lowercase_      :    Any       		= pipeline(
										    task="""text-classification"""       ,    model="""hf-internal-testing/tiny-random-distilbert"""       ,    framework="""pt"""					)

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

										lowercase_      :    Optional[Any]       		= 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}]					)

										lowercase_      :    Any       		= 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}],
										    ]       ,    )

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

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

										lowercase_      :    List[str]       		= 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}]]					)

										lowercase_      :    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_04}, {"""label""": """LABEL_1""", """score""": 0.4_96}],
										        [{"""label""": """LABEL_0""", """score""": 0.5_04}, {"""label""": """LABEL_1""", """score""": 0.4_96}],
										    ]       ,    )

										lowercase_      :    str       		= 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 			SCREAMING_SNAKE_CASE_  (			self       :						Dict					):
										import torch

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

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







			@require_tf
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Dict					):
										lowercase_      :    Any       		= pipeline(
										    task="""text-classification"""       ,    model="""hf-internal-testing/tiny-random-distilbert"""       ,    framework="""tf"""					)

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







			@slow
			@require_torch
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Union[str, Any]					):
										lowercase_      :    Tuple       		= pipeline("""text-classification"""					)

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







			@slow
			@require_tf
			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[Any]					):
										lowercase_      :    List[str]       		= pipeline("""text-classification"""       ,    framework="""tf"""					)

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







			def 			SCREAMING_SNAKE_CASE_  (			self       :						Dict       ,    lowercase_       :						List[Any]       ,    lowercase_       :						Union[str, Any]       ,    lowercase_       :						Optional[int]					):
										lowercase_      :    Dict       		= TextClassificationPipeline(model=lowercase_       ,    tokenizer=lowercase_					)
										return text_classifier, ["HuggingFace is in", "This is another test"]







			def 			SCREAMING_SNAKE_CASE_  (			self       :						str       ,    lowercase_       :						List[str]       ,    lowercase_       :						Union[str, Any]					):
										lowercase_      :    Tuple       		= text_classifier.model
										# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
										lowercase_      :    Optional[Any]       		= """HuggingFace is in"""
										lowercase_      :    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()					)

										lowercase_      :    int       		= ["""HuggingFace is in """, """Paris is in France"""]
										lowercase_      :    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
										lowercase_      :    List[Any]       		= text_classifier(lowercase_       ,    top_k=lowercase_					)
										lowercase_      :    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]       ,    )

										lowercase_      :    int       		= {"""text""": """HuggingFace is in """, """text_pair""": """Paris is in France"""}
										lowercase_      :    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.
										lowercase_      :    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
										lowercase_      :    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'''




import pytest

import datasets.config
from datasets.utils.info_utils import is_small_dataset




@pytest.mark.parametrize("""dataset_size"""   ,   [None, 400 * 2**20, 600 * 2**20]				)
@pytest.mark.parametrize("""input_in_memory_max_size"""   ,   ["""default""", 0, 100 * 2**20, 900 * 2**20]				)
def 							lowerCamelCase			(   UpperCAmelCase__ :      Union[str, Any]   ,   UpperCAmelCase__ :      List[Any]   ,   UpperCAmelCase__ :      str				)    ->   Any:
							if input_in_memory_max_size != "default":
														monkeypatch.setattr(datasets.config   ,   """IN_MEMORY_MAX_SIZE"""   ,   UpperCAmelCase__				)
							lowercase_      :    List[Any]       		= datasets.config.IN_MEMORY_MAX_SIZE
							if input_in_memory_max_size == "default":
														assert in_memory_max_size == 0
							else:
														assert in_memory_max_size == input_in_memory_max_size
							if dataset_size and in_memory_max_size:
														lowercase_      :    str       		= dataset_size < in_memory_max_size
							else:
														lowercase_      :    List[Any]       		= False
							lowercase_      :    Any       		= is_small_dataset(UpperCAmelCase__				)
							assert result == expected





