






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   ):






      '''simple docstring'''




      __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       __lowerCAmelCase					(      self      :						str  )    ->List[Any]:




       """simple docstring"""


       a		  =      pipeline(
           task='''text-classification''' ,					model='''hf-internal-testing/tiny-random-distilbert''' ,					framework='''pt'''  )

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

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

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

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

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

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

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

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







      @require_torch
      def       __lowerCAmelCase					(      self      :						Dict  )    ->Any:




       """simple docstring"""


       import torch

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

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







      @require_tf
      def       __lowerCAmelCase					(      self      :						List[str]  )    ->Dict:




       """simple docstring"""


       a		  =      pipeline(
           task='''text-classification''' ,					model='''hf-internal-testing/tiny-random-distilbert''' ,					framework='''tf'''  )

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







      @slow
      @require_torch
      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->Union[str, Any]:




       """simple docstring"""


       a		  =      pipeline('''text-classification'''  )

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







      @slow
      @require_tf
      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->Union[str, Any]:




       """simple docstring"""


       a		  =      pipeline('''text-classification''' ,					framework='''tf'''  )

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







      def       __lowerCAmelCase					(      self      :						Union[str, Any] ,					__UpperCAmelCase      :						List[Any] ,					__UpperCAmelCase      :						Optional[Any] ,					__UpperCAmelCase      :						Tuple  )    ->str:




       """simple docstring"""


       a		  =      TextClassificationPipeline(model=__UpperCAmelCase ,					tokenizer=__UpperCAmelCase  )
       return text_classifier, ["HuggingFace is in", "This is another test"]







      def       __lowerCAmelCase					(      self      :						Any ,					__UpperCAmelCase      :						Optional[Any] ,					__UpperCAmelCase      :						str  )    ->Optional[Any]:




       """simple docstring"""


       a		  =      text_classifier.model
       # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
       a		  =      '''HuggingFace is in'''
       a		  =      text_classifier(__UpperCAmelCase  )

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

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

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

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








"""simple docstring"""




from typing import Any



def     a__ (				snake_case__       , snake_case__       , snake_case__       , snake_case__       , snake_case__       , )						->					list:
			_validation(
			    snake_case__       , snake_case__       , snake_case__       , snake_case__       , snake_case__       , )
			# Creates data structures and fill initial step
			lowerCamelCase			      =					{}
			lowerCamelCase			      =					{}
			for state in states_space:
						lowerCamelCase			      =					observations_space[0]
						lowerCamelCase			      =					(
						    initial_probabilities[state] * emission_probabilities[state][observation]
						)
						lowerCamelCase			      =					None

			# Fills the data structure with the probabilities of
			# different transitions and pointers to previous states
			for o in range(1       , len(snake_case__				)				):
						lowerCamelCase			      =					observations_space[o]
						lowerCamelCase			      =					observations_space[o - 1]
						for state in states_space:
									# Calculates the argmax for probability function
									lowerCamelCase			      =					""""""
									lowerCamelCase			      =					-1
									for k_state in states_space:
												lowerCamelCase			      =					(
												    probabilities[(k_state, prior_observation)]
												    * transition_probabilities[k_state][state]
												    * emission_probabilities[state][observation]
												)
												if probability > max_probability:
															lowerCamelCase			      =					probability
															lowerCamelCase			      =					k_state

            # Update probabilities and pointers dicts
									lowerCamelCase			      =					(
									    probabilities[(arg_max, prior_observation)]
									    * transition_probabilities[arg_max][state]
									    * emission_probabilities[state][observation]
									)

									lowerCamelCase			      =					arg_max

    # The final observation
			lowerCamelCase			      =					observations_space[len(snake_case__				) - 1]

			# argmax for given final observation
			lowerCamelCase			      =					""""""
			lowerCamelCase			      =					-1
			for k_state in states_space:
						lowerCamelCase			      =					probabilities[(k_state, final_observation)]
						if probability > max_probability:
									lowerCamelCase			      =					probability
									lowerCamelCase			      =					k_state
			lowerCamelCase			      =					arg_max

			# Process pointers backwards
			lowerCamelCase			      =					last_state
			lowerCamelCase			      =					[]
			for o in range(len(snake_case__				) - 1       , -1       , -1				):
						result.append(snake_case__				)
						lowerCamelCase			      =					pointers[previous, observations_space[o]]
			result.reverse()

			return result



def     a__ (				snake_case__       , snake_case__       , snake_case__       , snake_case__       , snake_case__       , )						->					None:
			_validate_not_empty(
			    snake_case__       , snake_case__       , snake_case__       , snake_case__       , snake_case__       , )
			_validate_lists(snake_case__       , snake_case__				)
			_validate_dicts(
			    snake_case__       , snake_case__       , snake_case__				)



def     a__ (				snake_case__       , snake_case__       , snake_case__       , snake_case__       , snake_case__       , )						->					None:
			if not all(
			    [
			        observations_space,
			        states_space,
			        initial_probabilities,
			        transition_probabilities,
			        emission_probabilities,
			    ]				):
						raise ValueError("""There's an empty parameter"""				)



def     a__ (				snake_case__       , snake_case__				)						->					None:
			_validate_list(snake_case__       , """observations_space"""				)
			_validate_list(snake_case__       , """states_space"""				)



def     a__ (				snake_case__       , snake_case__				)						->					None:
			if not isinstance(_object       , snake_case__				):
						lowerCamelCase			      =					F'{var_name} must be a list'
						raise ValueError(snake_case__				)
			else:
						for x in _object:
									if not isinstance(snake_case__       , snake_case__				):
												lowerCamelCase			      =					F'{var_name} must be a list of strings'
												raise ValueError(snake_case__				)



def     a__ (				snake_case__       , snake_case__       , snake_case__       , )						->					None:
			_validate_dict(snake_case__       , """initial_probabilities"""       , snake_case__				)
			_validate_nested_dict(snake_case__       , """transition_probabilities"""				)
			_validate_nested_dict(snake_case__       , """emission_probabilities"""				)



def     a__ (				snake_case__       , snake_case__				)						->					None:
			_validate_dict(_object       , snake_case__       , snake_case__				)
			for x in _object.values():
						_validate_dict(snake_case__       , snake_case__       , snake_case__       , snake_case__				)



def     a__ (				snake_case__       , snake_case__       , snake_case__       , snake_case__ = False				)						->					None:
			if not isinstance(_object       , snake_case__				):
						lowerCamelCase			      =					F'{var_name} must be a dict'
						raise ValueError(snake_case__				)
			if not all(isinstance(snake_case__       , snake_case__				) for x in _object				):
						lowerCamelCase			      =					F'{var_name} all keys must be strings'
						raise ValueError(snake_case__				)
			if not all(isinstance(snake_case__       , snake_case__				) for x in _object.values()				):
						lowerCamelCase			      =					"""nested dictionary """ if nested else """"""
						lowerCamelCase			      =					F'{var_name} {nested_text}all values must be {value_type.__name__}'
						raise ValueError(snake_case__				)


if __name__ == "__main__":
					from doctest import testmod

					testmod()



