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 			lowerCamelCase_  (     unittest.TestCase				):






				'''simple docstring'''






				a__			:		Dict      			=   MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
				a__			:		str      			=   TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

				if model_mapping is not None:
								a__			:		Union[str, Any]      			=   {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
				if tf_model_mapping is not None:
								a__			:		List[str]      			=   {
								    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
								}







				@require_torch
				def     UpperCamelCase__     (			self) ->			Dict:
								__UpperCamelCase  :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(__lowercase)				,				[{'''label''': '''LABEL_0''', '''score''': 0.5_04}])

								__UpperCamelCase  :List[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}])

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

								__UpperCamelCase  :Optional[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_0''', '''score''': 0.5_04},
								    ]				,				)







				@require_torch
				def     UpperCamelCase__     (			self) ->			Any:
								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) ->			Dict:
								__UpperCamelCase  :int    						=	pipeline(
								    task='''text-classification'''				,				model='''hf-internal-testing/tiny-random-distilbert'''				,				framework='''tf''')

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







				@slow
				@require_torch
				def     UpperCamelCase__     (			self) ->			List[Any]:
								__UpperCamelCase  :Union[str, Any]    						=	pipeline('''text-classification''')

								__UpperCamelCase  :Dict    						=	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  :Tuple    						=	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) ->			int:
								__UpperCamelCase  :Union[str, Any]    						=	pipeline('''text-classification'''				,				framework='''tf''')

								__UpperCamelCase  :Optional[int]    						=	text_classifier('''This is great !''')
								self.assertEqual(nested_simplify(__lowercase)				,				[{'''label''': '''POSITIVE''', '''score''': 1.0}])
								__UpperCamelCase  :Optional[int]    						=	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) ->			Optional[Any]:
								__UpperCamelCase  :Optional[int]    						=	TextClassificationPipeline(model=__lowercase				,				tokenizer=__lowercase)
								return text_classifier, ["HuggingFace is in", "This is another test"]







				def     UpperCamelCase__     (			self				,				__lowercase				,				__lowercase) ->			str:
								__UpperCamelCase  :int    						=	text_classifier.model
								# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
								__UpperCamelCase  :List[Any]    						=	'''HuggingFace is in'''
								__UpperCamelCase  :Optional[int]    						=	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  :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  :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  :Tuple    						=	{'''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  :List[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  :List[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())






def lowerCamelCase						(     SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :Optional[int]    						=	generate_pascal_triangle(SCREAMING_SNAKE_CASE			)
    for row_idx in range(SCREAMING_SNAKE_CASE			):
        # Print left spaces
        for _ in range(num_rows - row_idx - 1			):
            print(end=''' '''			)
        # Print row values
        for col_idx in range(row_idx + 1			):
            if col_idx != row_idx:
                print(triangle[row_idx][col_idx]						,    end=''' '''			)
            else:
                print(triangle[row_idx][col_idx]						,    end=''''''			)
        print()



def lowerCamelCase						(     SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    if not isinstance(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
        raise TypeError('''The input value of \'num_rows\' should be \'int\''''			)

    if num_rows == 0:
        return []
    elif num_rows < 0:
        raise ValueError(
            '''The input value of \'num_rows\' should be greater than or equal to 0'''			)

    __UpperCamelCase  :list[list[int]]    						=	[]
    for current_row_idx in range(SCREAMING_SNAKE_CASE			):
        __UpperCamelCase  :List[Any]    						=	populate_current_row(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)
        triangle.append(SCREAMING_SNAKE_CASE			)
    return triangle



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    __UpperCamelCase  :int    						=	[-1] * (current_row_idx + 1)
    # first and last elements of current row are equal to 1
    __UpperCamelCase						, __UpperCamelCase  :int    						=	1, 1
    for current_col_idx in range(1						,    SCREAMING_SNAKE_CASE			):
        calculate_current_element(
            SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)
    return current_row



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    ):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	triangle[current_row_idx - 1][current_col_idx - 1]
    __UpperCamelCase  :List[Any]    						=	triangle[current_row_idx - 1][current_col_idx]
    __UpperCamelCase  :List[Any]    						=	above_to_left_elt + above_to_right_elt



def lowerCamelCase						(     SCREAMING_SNAKE_CASE			):
    '''simple docstring'''







    if not isinstance(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
        raise TypeError('''The input value of \'num_rows\' should be \'int\''''			)

    if num_rows == 0:
        return []
    elif num_rows < 0:
        raise ValueError(
            '''The input value of \'num_rows\' should be greater than or equal to 0'''			)

    __UpperCamelCase  :list[list[int]]    						=	[[1]]

    for row_index in range(1						,    SCREAMING_SNAKE_CASE			):
        __UpperCamelCase  :Optional[Any]    						=	[0] + result[-1] + [0]
        __UpperCamelCase  :Any    						=	row_index + 1
        # Calculate the number of distinct elements in a row
        __UpperCamelCase  :Optional[Any]    						=	sum(divmod(SCREAMING_SNAKE_CASE						,    2			)			)
        __UpperCamelCase  :Union[str, Any]    						=	[
            temp_row[i - 1] + temp_row[i] for i in range(1						,    distinct_elements + 1			)
        ]
        __UpperCamelCase  :List[Any]    						=	row_first_half[: (row_index + 1) // 2]
        row_second_half.reverse()
        __UpperCamelCase  :List[str]    						=	row_first_half + row_second_half
        result.append(SCREAMING_SNAKE_CASE			)

    return result



def lowerCamelCase						(     ):
    '''simple docstring'''







    from collections.abc import Callable
    from timeit import timeit

    def benchmark_a_function(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			) -> None:
        __UpperCamelCase  :List[str]    						=	f"""{func.__name__}({value})"""
        __UpperCamelCase  :Optional[int]    						=	timeit(f"""__main__.{call}"""						,    setup='''import __main__'''			)
        # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
        print(f"""{call:38} -- {timing:.4f} seconds"""			)

    for value in range(15			):  # (1, 7, 14):
        for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
            benchmark_a_function(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)
        print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()





