





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


  '''simple docstring'''
  a_							:       List[Any]      					=MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  a_							:       Optional[Any]      					=TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







  @require_torch
  def UpperCamelCase_ (      self      :					List[Any]							):


    '''simple docstring'''





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

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

    _snake_case   :				Any														=	text_classifier('This is great !'      ,				top_k=2							)
    self.assertEqual(
        nested_simplify(UpperCamelCase							)      ,				[{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}]							)

    _snake_case   :				Any														=	text_classifier(['This is great !', 'This is bad']      ,				top_k=2							)
    self.assertEqual(
        nested_simplify(UpperCamelCase							)      ,				[
            [{'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}],
        ]      ,				)

    _snake_case   :				int														=	text_classifier('This is great !'      ,				top_k=1							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'LABEL_0', 'score': 0.5_04}]							)

    # Legacy behavior
    _snake_case   :				str														=	text_classifier('This is great !'      ,				return_all_scores=UpperCamelCase							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'LABEL_0', 'score': 0.5_04}]							)

    _snake_case   :				str														=	text_classifier('This is great !'      ,				return_all_scores=UpperCamelCase							)
    self.assertEqual(
        nested_simplify(UpperCamelCase							)      ,				[[{'label': 'LABEL_0', 'score': 0.5_04}, {'label': 'LABEL_1', 'score': 0.4_96}]]							)

    _snake_case   :				Optional[int]														=	text_classifier(['This is great !', 'Something else']      ,				return_all_scores=UpperCamelCase							)
    self.assertEqual(
        nested_simplify(UpperCamelCase							)      ,				[
            [{'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}],
        ]      ,				)

    _snake_case   :				Any														=	text_classifier(['This is great !', 'Something else']      ,				return_all_scores=UpperCamelCase							)
    self.assertEqual(
        nested_simplify(UpperCamelCase							)      ,				[
            {'label': 'LABEL_0', 'score': 0.5_04},
            {'label': 'LABEL_0', 'score': 0.5_04},
        ]      ,				)







  @require_torch
  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    import torch

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

    _snake_case   :				List[str]														=	text_classifier('This is great !'							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'LABEL_0', 'score': 0.5_04}]							)







  @require_tf
  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





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

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







  @slow
  @require_torch
  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	pipeline('text-classification'							)

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







  @slow
  @require_tf
  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				int														=	pipeline('text-classification'      ,				framework='tf'							)

    _snake_case   :				Tuple														=	text_classifier('This is great !'							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'POSITIVE', 'score': 1.0}]							)
    _snake_case   :				Union[str, Any]														=	text_classifier('This is bad !'							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'NEGATIVE', 'score': 1.0}]							)
    _snake_case   :				List[str]														=	text_classifier('Birds are a type of animal'							)
    self.assertEqual(nested_simplify(UpperCamelCase							)      ,				[{'label': 'POSITIVE', 'score': 0.9_88}]							)







  def UpperCamelCase_ (      self      :					Tuple      ,				UpperCamelCase      :					Dict      ,				UpperCamelCase      :					List[str]      ,				UpperCamelCase      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				str														=	TextClassificationPipeline(model=UpperCamelCase      ,				tokenizer=UpperCamelCase							)
    return text_classifier, ["HuggingFace is in", "This is another test"]







  def UpperCamelCase_ (      self      :					Optional[Any]      ,				UpperCamelCase      :					Tuple      ,				UpperCamelCase      :					Tuple							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	text_classifier.model
    # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
    _snake_case   :				int														=	'HuggingFace is in'
    _snake_case   :				str														=	text_classifier(UpperCamelCase							)

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

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

    _snake_case   :				List[Any]														=	{'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
    _snake_case   :				Optional[Any]														=	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.
    _snake_case   :				List[Any]														=	[['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
    _snake_case   :				str														=	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()							)











import copy
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Optional, Union



@dataclass
class        _lowerCAmelCase    :


  '''simple docstring'''
  a_							:       Optional[Union[str, Path]]      					=None
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       Optional[Dict]      					=None
  a_							:       Optional[str]      					=None
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=True
  a_							:       Optional[int]      					=None
  a_							:       int      					=1
  a_							:       Optional[Union[str, bool]]      					=None
  a_							:       bool      					=False
  a_							:       Optional[Dict]      					=None
  a_							:       Optional[str]      					=None







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    return self.__class__(**{k: copy.deepcopy(UpperCamelCase							) for k, v in self.__dict__.items()}							)




