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  :     Optional[int]       =  {"""LayoutLMv2Config""", """LayoutLMv3Config"""}




@is_pipeline_test
class    _UpperCamelCase      (						unittest.TestCase ):


			"""simple docstring"""






			__a  : List[Any]			 =						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			__a  : Any			 =						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						__a  : Dict			 =						{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        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


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

							__lowercase 			=							text_classifier('''This is great !'''						)
							self.assertEqual(nested_simplify(lowerCAmelCase__						)      ,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]						)

							__lowercase 			=							text_classifier('''This is great !'''      ,   top_k=2						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]						)

							__lowercase 			=							text_classifier(['''This is great !''', '''This is bad''']      ,   top_k=2						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							    ]      ,   )

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

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

							__lowercase 			=							text_classifier('''This is great !'''      ,   return_all_scores=lowerCAmelCase__						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [[{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]]						)

							__lowercase 			=							text_classifier(['''This is great !''', '''Something else''']      ,   return_all_scores=lowerCAmelCase__						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							    ]      ,   )

							__lowercase 			=							text_classifier(['''This is great !''', '''Something else''']      ,   return_all_scores=lowerCAmelCase__						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [
							        {'''label''': '''LABEL_0''', '''score''': 0.504},
							        {'''label''': '''LABEL_0''', '''score''': 0.504},
							    ]      ,   )





			@require_torch
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							import torch

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

							__lowercase 			=							text_classifier('''This is great !'''						)
							self.assertEqual(nested_simplify(lowerCAmelCase__						)      ,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]						)





			@require_tf
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


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

							__lowercase 			=							text_classifier('''This is great !'''						)
							self.assertEqual(nested_simplify(lowerCAmelCase__						)      ,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]						)





			@slow
			@require_torch
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase 			=							pipeline('''text-classification'''						)

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





			@slow
			@require_tf
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


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

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





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Optional[int]:

							'''simple docstring'''


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





			def        _SCREAMING_SNAKE_CASE			(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)     ->					Optional[Any]:

							'''simple docstring'''


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

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

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

							__lowercase 			=							{'''text''': '''HuggingFace is in ''', '''text_pair''': '''Paris is in France'''}
							__lowercase 			=							text_classifier(lowerCAmelCase__						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   {'''label''': ANY(lowerCAmelCase__						), '''score''': ANY(lowerCAmelCase__						)}      ,   )
							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.
							__lowercase 			=							[['''HuggingFace is in ''', '''Paris is in France''']]
							with self.assertRaises(lowerCAmelCase__						):
											text_classifier(lowerCAmelCase__						)

							# This used to be valid for doing text pairs
							# We're keeping it working because of backward compatibility
							__lowercase 			=							text_classifier([[['''HuggingFace is in ''', '''Paris is in France''']]]						)
							self.assertEqual(
							    nested_simplify(lowerCAmelCase__						)      ,   [{'''label''': ANY(lowerCAmelCase__						), '''score''': ANY(lowerCAmelCase__						)}]      ,   )
							self.assertTrue(outputs[0]['''label'''] in model.config.idalabel.values()						)
import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


__a  :     int       =  logging.get_logger(__name__)

__a  :     str       =  {
    """ut/deta""": """https://huggingface.co/ut/deta/resolve/main/config.json""",
}




class    _UpperCamelCase      (						_UpperCAmelCase ):


			"""simple docstring"""






			__a  : Optional[int]			 =						'''deta'''
			__a  : Optional[int]			 =						{
			    '''hidden_size''': '''d_model''',
			    '''num_attention_heads''': '''encoder_attention_heads''',
			}





			def __init__(   self      ,   lowerCAmelCase__=None      ,   lowerCAmelCase__=9_00      ,   lowerCAmelCase__=20_48      ,   lowerCAmelCase__=6      ,   lowerCAmelCase__=20_48      ,   lowerCAmelCase__=8      ,   lowerCAmelCase__=6      ,   lowerCAmelCase__=10_24      ,   lowerCAmelCase__=8      ,   lowerCAmelCase__=0.0      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__="relu"      ,   lowerCAmelCase__=2_56      ,   lowerCAmelCase__=0.1      ,   lowerCAmelCase__=0.0      ,   lowerCAmelCase__=0.0      ,   lowerCAmelCase__=0.02      ,   lowerCAmelCase__=1.0      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=False      ,   lowerCAmelCase__="sine"      ,   lowerCAmelCase__=5      ,   lowerCAmelCase__=4      ,   lowerCAmelCase__=4      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=3_00      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=1      ,   lowerCAmelCase__=5      ,   lowerCAmelCase__=2      ,   lowerCAmelCase__=1      ,   lowerCAmelCase__=1      ,   lowerCAmelCase__=5      ,   lowerCAmelCase__=2      ,   lowerCAmelCase__=0.1      ,   lowerCAmelCase__=0.25      ,   **lowerCAmelCase__      ,   )     ->					List[Any]:

							'''simple docstring'''


							if backbone_config is None:
											logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''						)
											__lowercase 			=							CONFIG_MAPPING['''resnet'''](out_features=['''stage2''', '''stage3''', '''stage4''']						)
							else:
											if isinstance(lowerCAmelCase__      ,   lowerCAmelCase__						):
															__lowercase 			=							backbone_config.pop('''model_type'''						)
															__lowercase 			=							CONFIG_MAPPING[backbone_model_type]
															__lowercase 			=							config_class.from_dict(lowerCAmelCase__						)

							__lowercase 			=							backbone_config
							__lowercase 			=							num_queries
							__lowercase 			=							max_position_embeddings
							__lowercase 			=							d_model
							__lowercase 			=							encoder_ffn_dim
							__lowercase 			=							encoder_layers
							__lowercase 			=							encoder_attention_heads
							__lowercase 			=							decoder_ffn_dim
							__lowercase 			=							decoder_layers
							__lowercase 			=							decoder_attention_heads
							__lowercase 			=							dropout
							__lowercase 			=							attention_dropout
							__lowercase 			=							activation_dropout
							__lowercase 			=							activation_function
							__lowercase 			=							init_std
							__lowercase 			=							init_xavier_std
							__lowercase 			=							encoder_layerdrop
							__lowercase 			=							auxiliary_loss
							__lowercase 			=							position_embedding_type
							# deformable attributes
							__lowercase 			=							num_feature_levels
							__lowercase 			=							encoder_n_points
							__lowercase 			=							decoder_n_points
							__lowercase 			=							two_stage
							__lowercase 			=							two_stage_num_proposals
							__lowercase 			=							with_box_refine
							__lowercase 			=							assign_first_stage
							if two_stage is True and with_box_refine is False:
											raise ValueError('''If two_stage is True, with_box_refine must be True.'''						)
							# Hungarian matcher
							__lowercase 			=							class_cost
							__lowercase 			=							bbox_cost
							__lowercase 			=							giou_cost
							# Loss coefficients
							__lowercase 			=							mask_loss_coefficient
							__lowercase 			=							dice_loss_coefficient
							__lowercase 			=							bbox_loss_coefficient
							__lowercase 			=							giou_loss_coefficient
							__lowercase 			=							eos_coefficient
							__lowercase 			=							focal_alpha
							super().__init__(is_encoder_decoder=lowerCAmelCase__      ,   **lowerCAmelCase__						)





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							return self.encoder_attention_heads





			@property
			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							return self.d_model





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					List[str]:

							'''simple docstring'''


							__lowercase 			=							copy.deepcopy(self.__dict__						)
							__lowercase 			=							self.backbone_config.to_dict()
							__lowercase 			=							self.__class__.model_type
							return output