"""simple docstring"""







from __future__ import annotations

import unittest

from transformers import CTRLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers.models.ctrl.modeling_tf_ctrl import (
         TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFCTRLForSequenceClassification,
         TFCTRLLMHeadModel,
         TFCTRLModel,
     )






class     _SCREAMING_SNAKE_CASE       ( UpperCAmelCase							):



   '''simple docstring'''



   def __init__(  self   ,							_SCREAMING_SNAKE_CASE   ,							):


      '''simple docstring'''

      __lowerCamelCase								=				parent
      __lowerCamelCase								=				13
      __lowerCamelCase								=				7
      __lowerCamelCase								=				True
      __lowerCamelCase								=				True
      __lowerCamelCase								=				True
      __lowerCamelCase								=				True
      __lowerCamelCase								=				True
      __lowerCamelCase								=				99
      __lowerCamelCase								=				32
      __lowerCamelCase								=				2
      __lowerCamelCase								=				4
      __lowerCamelCase								=				37
      __lowerCamelCase								=				'gelu'
      __lowerCamelCase								=				0.1
      __lowerCamelCase								=				0.1
      __lowerCamelCase								=				512
      __lowerCamelCase								=				16
      __lowerCamelCase								=				2
      __lowerCamelCase								=				0.02
      __lowerCamelCase								=				3
      __lowerCamelCase								=				4
      __lowerCamelCase								=				None
      __lowerCamelCase								=				self.vocab_size - 1







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				ids_tensor([self.batch_size, self.seq_length]   ,							self.vocab_size  )

      __lowerCamelCase								=				None
      if self.use_input_mask:
         __lowerCamelCase								=				random_attention_mask([self.batch_size, self.seq_length]  )

      __lowerCamelCase								=				None
      if self.use_token_type_ids:
         __lowerCamelCase								=				ids_tensor([self.batch_size, self.seq_length]   ,							self.type_vocab_size  )

      __lowerCamelCase								=				None
      if self.use_mc_token_ids:
         __lowerCamelCase								=				ids_tensor([self.batch_size, self.num_choices]   ,							self.seq_length  )

      __lowerCamelCase								=				None
      __lowerCamelCase								=				None
      __lowerCamelCase								=				None
      if self.use_labels:
         __lowerCamelCase								=				ids_tensor([self.batch_size]   ,							self.type_sequence_label_size  )
         __lowerCamelCase								=				ids_tensor([self.batch_size, self.seq_length]   ,							self.num_labels  )
         __lowerCamelCase								=				ids_tensor([self.batch_size]   ,							self.num_choices  )

      __lowerCamelCase								=				CTRLConfig(
          vocab_size=self.vocab_size   ,							n_embd=self.hidden_size   ,							n_layer=self.num_hidden_layers   ,							n_head=self.num_attention_heads   ,							n_positions=self.max_position_embeddings   ,							pad_token_id=self.pad_token_id   ,							)

      __lowerCamelCase								=				ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,							2  )

      return (
          config,
          input_ids,
          input_mask,
          head_mask,
          token_type_ids,
          mc_token_ids,
          sequence_labels,
          token_labels,
          choice_labels,
      )







   def       _A							(  self   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							*_SCREAMING_SNAKE_CASE  ):


      '''simple docstring'''

      __lowerCamelCase								=				TFCTRLModel(config=_SCREAMING_SNAKE_CASE  )
      __lowerCamelCase								=				{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      __lowerCamelCase								=				model(_SCREAMING_SNAKE_CASE  )

      __lowerCamelCase								=				[input_ids, None, input_mask]  # None is the input for 'past'
      __lowerCamelCase								=				model(_SCREAMING_SNAKE_CASE  )

      __lowerCamelCase								=				model(_SCREAMING_SNAKE_CASE  )

      self.parent.assertEqual(result.last_hidden_state.shape   ,							(self.batch_size, self.seq_length, self.hidden_size)  )







   def       _A							(  self   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							*_SCREAMING_SNAKE_CASE  ):


      '''simple docstring'''

      __lowerCamelCase								=				TFCTRLLMHeadModel(config=_SCREAMING_SNAKE_CASE  )
      __lowerCamelCase								=				{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      __lowerCamelCase								=				model(_SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.seq_length, self.vocab_size)  )







   def       _A							(  self   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							*_SCREAMING_SNAKE_CASE  ):


      '''simple docstring'''

      __lowerCamelCase								=				self.num_labels
      __lowerCamelCase								=				ids_tensor([self.batch_size]   ,							self.type_sequence_label_size  )
      __lowerCamelCase								=				{
          'input_ids': input_ids,
          'token_type_ids': token_type_ids,
          'labels': sequence_labels,
      }
      __lowerCamelCase								=				TFCTRLForSequenceClassification(_SCREAMING_SNAKE_CASE  )
      __lowerCamelCase								=				model(_SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.num_labels)  )







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				self.prepare_config_and_inputs()

      (
          (
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,(
          __lowerCamelCase
      )		,
      )								=				config_and_inputs

      __lowerCamelCase								=				{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
      return config, inputs_dict






@require_tf
class     _SCREAMING_SNAKE_CASE       ( UpperCAmelCase						,							UpperCAmelCase						,							unittest.TestCase							):



   '''simple docstring'''



   __UpperCAmelCase  :       str						=						(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
   __UpperCAmelCase  :       int						=						(TFCTRLLMHeadModel,) if is_tf_available() else ()
   __UpperCAmelCase  :       Tuple						=						(
       {
           "feature-extraction": TFCTRLModel,
           "text-classification": TFCTRLForSequenceClassification,
           "text-generation": TFCTRLLMHeadModel,
           "zero-shot": TFCTRLForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __UpperCAmelCase  :       Any						=						False
   __UpperCAmelCase  :       Tuple						=						False







   def       _A							(  self   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE  ):


      '''simple docstring'''

      if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
         # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
         # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
         # config could not be created.
         return True

      return False







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				TFCTRLModelTester(self  )
      __lowerCamelCase								=				ConfigTester(self   ,							config_class=_SCREAMING_SNAKE_CASE   ,							n_embd=37  )







   def       _A							(  self  ):


      '''simple docstring'''

      self.config_tester.run_common_tests()







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_model(*_SCREAMING_SNAKE_CASE  )







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_lm_head(*_SCREAMING_SNAKE_CASE  )







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_for_sequence_classification(*_SCREAMING_SNAKE_CASE  )







   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase								=				self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCamelCase								=				[TFCTRLLMHeadModel]
      __lowerCamelCase								=				[TFCTRLForSequenceClassification]

      for model_class in self.all_model_classes:
         __lowerCamelCase								=				model_class(_SCREAMING_SNAKE_CASE  )
         model.build()  # may be needed for the get_bias() call below
         assert isinstance(model.get_input_embeddings()   ,							tf.keras.layers.Layer  )

         if model_class in list_lm_models:
            __lowerCamelCase								=				model.get_output_embeddings()
            assert isinstance(_SCREAMING_SNAKE_CASE   ,							tf.keras.layers.Layer  )
            __lowerCamelCase								=				model.get_bias()
            assert isinstance(_SCREAMING_SNAKE_CASE   ,							_SCREAMING_SNAKE_CASE  )
            for k, v in name.items():
               assert isinstance(_SCREAMING_SNAKE_CASE   ,							tf.Variable  )
         elif model_class in list_other_models_with_output_ebd:
            __lowerCamelCase								=				model.get_output_embeddings()
            assert isinstance(_SCREAMING_SNAKE_CASE   ,							tf.keras.layers.Layer  )
            __lowerCamelCase								=				model.get_bias()
            assert name is None
         else:
            __lowerCamelCase								=				model.get_output_embeddings()
            assert x is None
            __lowerCamelCase								=				model.get_bias()
            assert name is None







   @slow
   def       _A							(  self  ):


      '''simple docstring'''

      for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __lowerCamelCase								=				TFCTRLModel.from_pretrained(_SCREAMING_SNAKE_CASE  )
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE  )






@require_tf
class     _SCREAMING_SNAKE_CASE       ( unittest.TestCase							):



   '''simple docstring'''



   @slow
   def       _A							(  self  ):


      '''simple docstring'''

      __lowerCamelCase								=				TFCTRLLMHeadModel.from_pretrained('ctrl'  )
      __lowerCamelCase								=				tf.convert_to_tensor([[11859, 0, 1611, 8]]   ,							dtype=tf.intaa  )  # Legal the president is
      __lowerCamelCase								=				[
          11859,
          0,
          1611,
          8,
          5,
          150,
          26449,
          2,
          19,
          348,
          469,
          3,
          2595,
          48,
          20740,
          246533,
          246533,
          19,
          30,
          5,
      ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

      __lowerCamelCase								=				model.generate(_SCREAMING_SNAKE_CASE   ,							do_sample=_SCREAMING_SNAKE_CASE  )
      self.assertListEqual(output_ids[0].numpy().tolist()   ,							_SCREAMING_SNAKE_CASE  )







"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_SCREAMING_SNAKE_CASE  :		List[Any]        =      {
    '''configuration_deformable_detr''': ['''DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DeformableDetrConfig'''],
}

try:
     if not is_vision_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _SCREAMING_SNAKE_CASE  :		Optional[Any]        =      ['''DeformableDetrFeatureExtractor''']
     _SCREAMING_SNAKE_CASE  :		List[str]        =      ['''DeformableDetrImageProcessor''']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _SCREAMING_SNAKE_CASE  :		Union[str, Any]        =      [
         '''DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''DeformableDetrForObjectDetection''',
         '''DeformableDetrModel''',
         '''DeformableDetrPreTrainedModel''',
     ]


if TYPE_CHECKING:
     from .configuration_deformable_detr import DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DeformableDetrConfig

     try:
          if not is_vision_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .feature_extraction_deformable_detr import DeformableDetrFeatureExtractor
          from .image_processing_deformable_detr import DeformableDetrImageProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_deformable_detr import (
              DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
              DeformableDetrForObjectDetection,
              DeformableDetrModel,
              DeformableDetrPreTrainedModel,
          )

else:
     import sys

     _SCREAMING_SNAKE_CASE  :		Tuple        =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






