





"""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      __SCREAMING_SNAKE_CASE    (						unittest.TestCase   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:Dict	     =					MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  SCREAMING_SNAKE_CASE__							:List[str]	     =					TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

  if model_mapping is not None:
    SCREAMING_SNAKE_CASE__							:Optional[int]	     =					{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    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				Any:
        _UpperCamelCase      :	Tuple						=       pipeline(
            task="text-classification"					,   model="hf-internal-testing/tiny-random-distilbert"					,   framework="pt"	)

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

        _UpperCamelCase      :	Union[str, Any]						=       text_classifier("This is great !"					,   top_k=2	)
        self.assertEqual(
            nested_simplify(__a	)					,   [{"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(__a	)					,   [
                [{"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      :	Tuple						=       text_classifier("This is great !"					,   top_k=1	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "LABEL_0", "score": 0.5_04}]	)

        # Legacy behavior
        _UpperCamelCase      :	Any						=       text_classifier("This is great !"					,   return_all_scores=__a	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "LABEL_0", "score": 0.5_04}]	)

        _UpperCamelCase      :	int						=       text_classifier("This is great !"					,   return_all_scores=__a	)
        self.assertEqual(
            nested_simplify(__a	)					,   [[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]]	)

        _UpperCamelCase      :	List[str]						=       text_classifier(["This is great !", "Something else"]					,   return_all_scores=__a	)
        self.assertEqual(
            nested_simplify(__a	)					,   [
                [{"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[Any]						=       text_classifier(["This is great !", "Something else"]					,   return_all_scores=__a	)
        self.assertEqual(
            nested_simplify(__a	)					,   [
                {"label": "LABEL_0", "score": 0.5_04},
                {"label": "LABEL_0", "score": 0.5_04},
            ]					,   )

  @require_torch
  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				Union[str, Any]:
        import torch

        _UpperCamelCase      :	List[str]						=       pipeline(
            task="text-classification"					,   model="hf-internal-testing/tiny-random-distilbert"					,   framework="pt"					,   device=torch.device("cpu"	)					,   )

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

  @require_tf
  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				Union[str, Any]:
        _UpperCamelCase      :	List[str]						=       pipeline(
            task="text-classification"					,   model="hf-internal-testing/tiny-random-distilbert"					,   framework="tf"	)

        _UpperCamelCase      :	Union[str, Any]						=       text_classifier("This is great !"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "LABEL_0", "score": 0.5_04}]	)

  @slow
  @require_torch
  def    __SCREAMING_SNAKE_CASE				(		self   :       Any	)		->				str:
        _UpperCamelCase      :	str						=       pipeline("text-classification"	)

        _UpperCamelCase      :	List[Any]						=       text_classifier("This is great !"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "POSITIVE", "score": 1.0}]	)
        _UpperCamelCase      :	Optional[Any]						=       text_classifier("This is bad !"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "NEGATIVE", "score": 1.0}]	)
        _UpperCamelCase      :	Any						=       text_classifier("Birds are a type of animal"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "POSITIVE", "score": 0.9_88}]	)

  @slow
  @require_tf
  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				Optional[Any]:
        _UpperCamelCase      :	Tuple						=       pipeline("text-classification"					,   framework="tf"	)

        _UpperCamelCase      :	int						=       text_classifier("This is great !"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "POSITIVE", "score": 1.0}]	)
        _UpperCamelCase      :	str						=       text_classifier("This is bad !"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "NEGATIVE", "score": 1.0}]	)
        _UpperCamelCase      :	Tuple						=       text_classifier("Birds are a type of animal"	)
        self.assertEqual(nested_simplify(__a	)					,   [{"label": "POSITIVE", "score": 0.9_88}]	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Any					,   __a   :       Any					,   __a   :       str					,   __a   :       Optional[Any]	)		->				int:
        _UpperCamelCase      :	Optional[int]						=       TextClassificationPipeline(model=__a					,   tokenizer=__a	)
        return text_classifier, ["HuggingFace is in", "This is another test"]


  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict					,   __a   :       Tuple					,   __a   :       str	)		->				Tuple:
        _UpperCamelCase      :	List[Any]						=       text_classifier.model
        # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
        _UpperCamelCase      :	List[str]						=       "HuggingFace is in"
        _UpperCamelCase      :	Tuple						=       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      :	Dict						=       ["HuggingFace is in ", "Paris is in France"]
        _UpperCamelCase      :	List[Any]						=       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      :	List[Any]						=       text_classifier(__a					,   top_k=__a	)
        _UpperCamelCase      :	Optional[Any]						=       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      :	List[str]						=       {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
        _UpperCamelCase      :	List[str]						=       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      :	Optional[int]						=       [["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      :	Optional[Any]						=       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"""


from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

lowerCamelCase__				  =   TypeVar("KEY")
lowerCamelCase__				  =   TypeVar("VAL")



@dataclass(frozen=_UpperCamelCase		,  slots=_UpperCamelCase   )
class      __SCREAMING_SNAKE_CASE    (						Generic[KEY, VAL]   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:KEY
  SCREAMING_SNAKE_CASE__							:VAL





class      __SCREAMING_SNAKE_CASE    (						_Item   ):







  '''simple docstring'''


  def __init__(		self   :       List[str]	)		->				None:
        super().__init__(__a					,   __a	)


  def __bool__(		self   :       Dict	)		->				bool:
        return False





lowerCamelCase__				  =   _DeletedItem()



class      __SCREAMING_SNAKE_CASE    (						MutableMapping[KEY, VAL]   ):







  '''simple docstring'''


  def __init__(		self   :       int					,   __a   :       int = 8					,   __a   :       float = 0.75	)		->				None:
        _UpperCamelCase      :	str						=       initial_block_size
        _UpperCamelCase      :	list[_Item | None]						=       [None] * initial_block_size
        assert 0.0 < capacity_factor < 1.0
        _UpperCamelCase      :	List[str]						=       capacity_factor
        _UpperCamelCase      :	Dict						=       0

  def    __SCREAMING_SNAKE_CASE				(		self   :       int					,   __a   :       KEY	)		->				int:
        return hash(__a	) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       int	)		->				int:
        return (ind + 1) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple					,   __a   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				bool:
        _UpperCamelCase      :	List[Any]						=       self._buckets[ind]
        if not stored:
              _UpperCamelCase      :	Tuple						=       _Item(__a					,   __a	)
              self._len += 1
              return True
        elif stored.key == key:
              _UpperCamelCase      :	Union[str, Any]						=       _Item(__a					,   __a	)
              return True
        else:
              return False

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				bool:
        _UpperCamelCase      :	Any						=       len(self._buckets	) * self._capacity_factor
        return len(self	) >= int(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				bool:
        if len(self._buckets	) <= self._initial_block_size:
              return False
        _UpperCamelCase      :	List[str]						=       len(self._buckets	) * self._capacity_factor / 2
        return len(self	) < limit

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]					,   __a   :       int	)		->				None:
        _UpperCamelCase      :	Any						=       self._buckets
        _UpperCamelCase      :	List[Any]						=       [None] * new_size
        _UpperCamelCase      :	List[str]						=       0
        for item in old_buckets:
              if item:
                    self._add_item(item.key					,   item.val	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				None:
        self._resize(len(self._buckets	) * 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				None:
        self._resize(len(self._buckets	) // 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       KEY	)		->				Iterator[int]:
        _UpperCamelCase      :	str						=       self._get_bucket_index(__a	)
        for _ in range(len(self._buckets	)	):
              yield ind
              _UpperCamelCase      :	Tuple						=       self._get_next_ind(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        for ind in self._iterate_buckets(__a	):
              if self._try_set(__a					,   __a					,   __a	):
                    break

  def __setitem__(		self   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        if self._is_full():
              self._size_up()

        self._add_item(__a					,   __a	)

  def __delitem__(		self   :       str					,   __a   :       KEY	)		->				None:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    raise KeyError(__a	)
              if item is _deleted:
                    continue
              if item.key == key:
                    _UpperCamelCase      :	List[Any]						=       _deleted
                    self._len -= 1
                    break
        if self._is_sparse():
              self._size_down()

  def __getitem__(		self   :       str					,   __a   :       KEY	)		->				VAL:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    break
              if item is _deleted:
                    continue
              if item.key == key:
                    return item.val
        raise KeyError(__a	)

  def __len__(		self   :       List[Any]	)		->				int:
        return self._len

  def __iter__(		self   :       List[str]	)		->				Iterator[KEY]:
        yield from (item.key for item in self._buckets if item)


  def __repr__(		self   :       List[str]	)		->				str:
        _UpperCamelCase      :	Optional[int]						=       " ,".join(
            F'''{item.key}: {item.val}''' for item in self._buckets if item	)
        return F'''HashMap({val_string})'''
