



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



@is_pipeline_test
class 						lowerCamelCase   (    unittest.TestCase	):







					'''simple docstring'''







					lowerCAmelCase_					:     List[Any]					       =	MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
					lowerCAmelCase_					:     int					       =	TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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



					@require_torch
					def  A__		(      self  ):
							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  A__		(      self  ):
							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  A__		(      self  ):
							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  A__		(      self  ):
							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  A__		(      self  ):
							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  A__		(      self     ,						lowerCAmelCase     ,						lowerCAmelCase     ,						lowerCAmelCase  ):
							UpperCAmelCase_						       =					TextClassificationPipeline(model=A_     ,						tokenizer=A_  )
							return text_classifier, ["HuggingFace is in", "This is another test"]



					def  A__		(      self     ,						lowerCAmelCase     ,						lowerCAmelCase  ):
							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()  )





def    a__    (		snake_case__					:							int						,   snake_case__					:							int     ):
  return x if y == 0 else greatest_common_divisor(snake_case__						,   x % y     )




def    a__    (		snake_case__					:							int						,   snake_case__					:							int     ):
  return (x * y) // greatest_common_divisor(snake_case__						,   snake_case__     )




def    a__    (		snake_case__					:							int = 20     ):
  _UpperCAmelCase		:							Union[str, Any]							=     1
  for i in range(1						,   n + 1     ):
    _UpperCAmelCase		:							Dict							=     lcm(snake_case__						,   snake_case__     )
  return g


if __name__ == "__main__":
 print(F'{solution() = }')





