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


@is_pipeline_test
class A_	(unittest.TestCase      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						int       =		MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  SCREAMING_SNAKE_CASE__			:						Optional[Any]       =		TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="pt"  )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     UpperCAmelCase_					:					Dict			     =    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_					:					int			     =    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_					:					List[Any]			     =    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_					:					Optional[Any]			     =    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_					:					Optional[int]			     =    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[int]			     =    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  ):

     """simple docstring"""
     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  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="tf"  )

     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )







  @slow
  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    pipeline("text-classification"  )

     UpperCAmelCase_					:					Tuple			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					int			     =    text_classifier("This is bad !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "NEGATIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					Optional[Any]			     =    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  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    pipeline("text-classification"				,   framework="tf"  )

     UpperCAmelCase_					:					int			     =    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_					:					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_  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    TextClassificationPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     return text_classifier, ["HuggingFace is in", "This is another test"]







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    text_classifier.model
     # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
     UpperCAmelCase_					:					str			     =    "HuggingFace is in"
     UpperCAmelCase_					:					Dict			     =    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_					:					List[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_					:					Optional[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_					:					List[Any]			     =    {"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_					:					Dict			     =    [["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_					:					Optional[int]			     =    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()  )




"""simple docstring"""





from collections import namedtuple

_a		       =							namedtuple('from_to', 'from_ to')

_a		       =							{
    'cubicmeter': from_to(1, 1),
    'litre': from_to(0.001, 1_000),
    'kilolitre': from_to(1, 1),
    'gallon': from_to(0.0_0454, 264.172),
    'cubicyard': from_to(0.7_6455, 1.3_0795),
    'cubicfoot': from_to(0.028, 35.3147),
    'cup': from_to(0.0_0023_6588, 4226.75),
}







def 	__a     (		__lowerCamelCase,		__lowerCamelCase,		__lowerCamelCase  ):
   if from_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   if to_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
    import doctest

    doctest.testmod()


