





'''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.
a__			:					Union[str, Any]       						=						{'LayoutLMv2Config', 'LayoutLMv3Config'}






@is_pipeline_test
class     lowerCAmelCase__ (				unittest.TestCase    ):

       '''simple docstring'''
       _lowerCamelCase								=MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       _lowerCamelCase								=TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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

       @require_torch
       def 			__snake_case      ( self					:				Dict						):
              UpperCAmelCase  =						pipeline(
                  task='''text-classification'''       ,     model='''hf-internal-testing/tiny-random-distilbert'''       ,     framework='''pt'''						)

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

              UpperCAmelCase  =						text_classifier('''This is great !'''       ,     top_k=2						)
              self.assertEqual(
                  nested_simplify(a__						)       ,     [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]						)

              UpperCAmelCase  =						text_classifier(['''This is great !''', '''This is bad''']       ,     top_k=2						)
              self.assertEqual(
                  nested_simplify(a__						)       ,     [
                      [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
                      [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
                  ]       ,     )

              UpperCAmelCase  =						text_classifier('''This is great !'''       ,     top_k=1						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''LABEL_0''', '''score''': 0.504}]						)

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

              UpperCAmelCase  =						text_classifier('''This is great !'''       ,     return_all_scores=a__						)
              self.assertEqual(
                  nested_simplify(a__						)       ,     [[{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]]						)

              UpperCAmelCase  =						text_classifier(['''This is great !''', '''Something else''']       ,     return_all_scores=a__						)
              self.assertEqual(
                  nested_simplify(a__						)       ,     [
                      [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
                      [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
                  ]       ,     )

              UpperCAmelCase  =						text_classifier(['''This is great !''', '''Something else''']       ,     return_all_scores=a__						)
              self.assertEqual(
                  nested_simplify(a__						)       ,     [
                      {'''label''': '''LABEL_0''', '''score''': 0.504},
                      {'''label''': '''LABEL_0''', '''score''': 0.504},
                  ]       ,     )

       @require_torch
       def 			__snake_case      ( self					:				Union[str, Any]						):
              import torch

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

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

       @require_tf
       def 			__snake_case      ( self					:				str						):
              UpperCAmelCase  =						pipeline(
                  task='''text-classification'''       ,     model='''hf-internal-testing/tiny-random-distilbert'''       ,     framework='''tf'''						)

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

       @slow
       @require_torch
       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						pipeline('''text-classification'''						)

              UpperCAmelCase  =						text_classifier('''This is great !'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''POSITIVE''', '''score''': 1.0}]						)
              UpperCAmelCase  =						text_classifier('''This is bad !'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''NEGATIVE''', '''score''': 1.0}]						)
              UpperCAmelCase  =						text_classifier('''Birds are a type of animal'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''POSITIVE''', '''score''': 0.988}]						)

       @slow
       @require_tf
       def 			__snake_case      ( self					:				str						):
              UpperCAmelCase  =						pipeline('''text-classification'''       ,     framework='''tf'''						)

              UpperCAmelCase  =						text_classifier('''This is great !'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''POSITIVE''', '''score''': 1.0}]						)
              UpperCAmelCase  =						text_classifier('''This is bad !'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''NEGATIVE''', '''score''': 1.0}]						)
              UpperCAmelCase  =						text_classifier('''Birds are a type of animal'''						)
              self.assertEqual(nested_simplify(a__						)       ,     [{'''label''': '''POSITIVE''', '''score''': 0.988}]						)

       def 			__snake_case      ( self					:				Optional[Any]       ,     a__					:				Tuple       ,     a__					:				List[Any]       ,     a__					:				Any						):
              UpperCAmelCase  =						TextClassificationPipeline(model=a__       ,     tokenizer=a__						)
              return text_classifier, ["HuggingFace is in", "This is another test"]



       def 			__snake_case      ( self					:				Any       ,     a__					:				int       ,     a__					:				Tuple						):
              UpperCAmelCase  =						text_classifier.model
              # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
              UpperCAmelCase  =						'''HuggingFace is in'''
              UpperCAmelCase  =						text_classifier(a__						)

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

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

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

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



"""simple docstring"""


def      lowerCamelCase_					(   __lowerCAmelCase							)				->   "list[int]":




						'''simple docstring'''



						if upper_limit < 0:
												raise ValueError("Limit for the Catalan sequence must be ≥ 0"							)

						lowerCamelCase__   =[0] * (upper_limit + 1)

						# Base case: C(0) = C(1) = 1
						lowerCamelCase__   =1
						if upper_limit > 0:
												lowerCamelCase__   =1

						# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
						for i in range(2  ,       upper_limit + 1							):
												for j in range(__lowerCAmelCase							):
																		catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

						return catalan_list


if __name__ == "__main__":
	print('\n********* Catalan Numbers Using Dynamic Programming ************\n')
	print('\n*** Enter -1 at any time to quit ***')
	print('\nEnter the upper limit (≥ 0) for the Catalan number sequence: ', end='')
	try:
		while True:
			a				=int(input().strip())
			if N < 0:
				print('\n********* Goodbye!! ************')
				break
			else:
				print(F'''The Catalan numbers from 0 through {N} are:''')
				print(catalan_numbers(N))
				print('Try another upper limit for the sequence: ', end='')
	except (NameError, ValueError):
		print('\n********* Invalid input, goodbye! ************\n')

	import doctest

	doctest.testmod()


