




'''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.
lowerCAmelCase_     						=				{'''LayoutLMv2Config''', '''LayoutLMv3Config'''}

@is_pipeline_test
class 	_snake_case(			unittest.TestCase      ):
 __snake_case:							Dict						=					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
 __snake_case:							List[Any]						=					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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






 @require_torch
 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   Tuple:






    """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(a    )    ,		[{'label': 'LABEL_0', 'score': 0.504}]    )

    A__       =     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}]    )

    A__       =     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}],
        ]    ,		)

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

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

    A__       =     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}]]    )

    A__       =     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}],
        ]    ,		)

    A__       =     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 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   int:






    """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(a    )    ,		[{'label': 'LABEL_0', 'score': 0.504}]    )






 @require_tf
 def 						_UpperCamelCase (self       :  Tuple    )       ->   str:






    """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(a    )    ,		[{'label': 'LABEL_0', 'score': 0.504}]    )






 @slow
 @require_torch
 def 						_UpperCamelCase (self       :  List[Any]    )       ->   Dict:






    """simple docstring"""


    A__       =     pipeline('text-classification'    )

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






 @slow
 @require_tf
 def 						_UpperCamelCase (self       :  int    )       ->   str:






    """simple docstring"""


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

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






 def 						_UpperCamelCase (self       :  Dict    ,		a       :  Any    ,		a       :  Tuple    ,		a       :  Any    )       ->   Optional[Any]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  List[str]    ,		a       :  Optional[Any]    ,		a       :  Any    )       ->   List[Any]:






    """simple docstring"""


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

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

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

    A__       =     {'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
    A__       =     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.
    A__       =     [['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
    A__       =     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 						_A      ( UpperCAmelCase = 1      ,UpperCAmelCase = 1000						):






   '''simple docstring'''







   A__       =     1
   A__       =     0

   for divide_by_number in range(UpperCAmelCase      ,digit + 1						):
      A__       =     []
      A__       =     numerator
      for _ in range(1      ,digit + 1						):
         if now_divide in has_been_divided:
            if longest_list_length < len(UpperCAmelCase						):
               A__       =     len(UpperCAmelCase						)
               A__       =     divide_by_number
         else:
            has_been_divided.append(UpperCAmelCase						)
            A__       =     now_divide * 10 % divide_by_number

   return the_digit


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()


