code: 
  
  
  """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 __snake_case		(					_SCREAMING_SNAKE_CASE      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     def __init__(		self							:int				,  UpperCamelCase__							:str				,  ):
            _a          =				parent
            _a          =				13
            _a          =				7
            _a          =				True
            _a          =				True
            _a          =				True
            _a          =				True
            _a          =				True
            _a          =				99
            _a          =				32
            _a          =				2
            _a          =				4
            _a          =				37
            _a          =				"gelu"
            _a          =				0.1
            _a          =				0.1
            _a          =				512
            _a          =				16
            _a          =				2
            _a          =				0.02
            _a          =				3
            _a          =				4
            _a          =				None
            _a          =				self.vocab_size - 1
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:str       ):
            _a          =				ids_tensor([self.batch_size, self.seq_length]				,  self.vocab_size       )
  
            _a          =				None
            if self.use_input_mask:
                   _a          =				random_attention_mask([self.batch_size, self.seq_length]       )
  
            _a          =				None
            if self.use_token_type_ids:
                   _a          =				ids_tensor([self.batch_size, self.seq_length]				,  self.type_vocab_size       )
  
            _a          =				None
            if self.use_mc_token_ids:
                   _a          =				ids_tensor([self.batch_size, self.num_choices]				,  self.seq_length       )
  
            _a          =				None
            _a          =				None
            _a          =				None
            if self.use_labels:
                   _a          =				ids_tensor([self.batch_size]				,  self.type_sequence_label_size       )
                   _a          =				ids_tensor([self.batch_size, self.seq_length]				,  self.num_labels       )
                   _a          =				ids_tensor([self.batch_size]				,  self.num_choices       )
  
            _a          =				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				,  )
  
            _a          =				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 SCREAMING_SNAKE_CASE_      (		self							:List[Any]				,  UpperCamelCase__							:Union[str, Any]				,  UpperCamelCase__							:str				,  UpperCamelCase__							:Optional[Any]				,  UpperCamelCase__							:Dict				,  UpperCamelCase__							:str				,  *UpperCamelCase__							:Optional[int]       ):
            _a          =				TFCTRLModel(config=UpperCamelCase__       )
            _a          =				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _a          =				model(UpperCamelCase__       )
  
            _a          =				[input_ids, None, input_mask]  # None is the input for 'past'
            _a          =				model(UpperCamelCase__       )
  
            _a          =				model(UpperCamelCase__       )
  
            self.parent.assertEqual(result.last_hidden_state.shape				,  (self.batch_size, self.seq_length, self.hidden_size)       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Dict				,  UpperCamelCase__							:Tuple				,  UpperCamelCase__							:Optional[Any]				,  UpperCamelCase__							:Tuple				,  UpperCamelCase__							:Optional[int]				,  UpperCamelCase__							:Any				,  *UpperCamelCase__							:Dict       ):
            _a          =				TFCTRLLMHeadModel(config=UpperCamelCase__       )
            _a          =				{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _a          =				model(UpperCamelCase__       )
            self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.seq_length, self.vocab_size)       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[Any]				,  UpperCamelCase__							:List[Any]				,  UpperCamelCase__							:Any				,  UpperCamelCase__							:Any				,  UpperCamelCase__							:Tuple				,  UpperCamelCase__							:Any				,  *UpperCamelCase__							:Optional[Any]       ):
            _a          =				self.num_labels
            _a          =				ids_tensor([self.batch_size]				,  self.type_sequence_label_size       )
            _a          =				{
                "input_ids": input_ids,
                "token_type_ids": token_type_ids,
                "labels": sequence_labels,
            }
            _a          =				TFCTRLForSequenceClassification(UpperCamelCase__       )
            _a          =				model(UpperCamelCase__       )
            self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.num_labels)       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Optional[Any]       ):
            _a          =				self.prepare_config_and_inputs()
  
            (
                (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , (
                _a
            )   , 
            )          =				config_and_inputs
  
            _a          =				{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
            return config, inputs_dict
  
  
  
  
  
  
  @require_tf
  class __snake_case		(					_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     lowerCAmelCase_				:   Optional[Any]     	=			(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
     lowerCAmelCase_				:   Tuple     	=			(TFCTRLLMHeadModel,) if is_tf_available() else ()
     lowerCAmelCase_				:   List[str]     	=			(
         {
             'feature-extraction': TFCTRLModel,
             'text-classification': TFCTRLForSequenceClassification,
             'text-generation': TFCTRLLMHeadModel,
             'zero-shot': TFCTRLForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     lowerCAmelCase_				:   Dict     	=			False
     lowerCAmelCase_				:   Optional[Any]     	=			False
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Tuple				,  UpperCamelCase__							:Dict				,  UpperCamelCase__							:Optional[int]				,  UpperCamelCase__							:str				,  UpperCamelCase__							:List[Any]				,  UpperCamelCase__							:int       ):
            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 SCREAMING_SNAKE_CASE_      (		self							:Optional[Any]       ):
            _a          =				TFCTRLModelTester(self       )
            _a          =				ConfigTester(self				,  config_class=UpperCamelCase__				,  n_embd=37       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[str]       ):
            self.config_tester.run_common_tests()
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[Any]       ):
            _a          =				self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_model(*UpperCamelCase__       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:str       ):
            _a          =				self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_lm_head(*UpperCamelCase__       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[Any]       ):
            _a          =				self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_for_sequence_classification(*UpperCamelCase__       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Union[str, Any]       ):
            _a   , _a          =				self.model_tester.prepare_config_and_inputs_for_common()
            _a          =				[TFCTRLLMHeadModel]
            _a          =				[TFCTRLForSequenceClassification]
  
            for model_class in self.all_model_classes:
                   _a          =				model_class(UpperCamelCase__       )
                   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:
                          _a          =				model.get_output_embeddings()
                          assert isinstance(UpperCamelCase__				,  tf.keras.layers.Layer       )
                          _a          =				model.get_bias()
                          assert isinstance(UpperCamelCase__				,  UpperCamelCase__       )
                          for k, v in name.items():
                                 assert isinstance(UpperCamelCase__				,  tf.Variable       )
                   elif model_class in list_other_models_with_output_ebd:
                          _a          =				model.get_output_embeddings()
                          assert isinstance(UpperCamelCase__				,  tf.keras.layers.Layer       )
                          _a          =				model.get_bias()
                          assert name is None
                   else:
                          _a          =				model.get_output_embeddings()
                          assert x is None
                          _a          =				model.get_bias()
                          assert name is None
  
  
  
  
     @slow
     def SCREAMING_SNAKE_CASE_      (		self							:Tuple       ):
            for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _a          =				TFCTRLModel.from_pretrained(UpperCamelCase__       )
                   self.assertIsNotNone(UpperCamelCase__       )
  
  
  
  
  
  
  @require_tf
  class __snake_case		(					unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     @slow
     def SCREAMING_SNAKE_CASE_      (		self							:Dict       ):
            _a          =				TFCTRLLMHeadModel.from_pretrained("ctrl"       )
            _a          =				tf.convert_to_tensor([[11_859, 0, 1_611, 8]]				,  dtype=tf.intaa       )  # Legal the president is
            _a          =				[
                11_859,
                0,
                1_611,
                8,
                5,
                150,
                26_449,
                2,
                19,
                348,
                469,
                3,
                2_595,
                48,
                20_740,
                246_533,
                246_533,
                19,
                30,
                5,
            ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a
  
            _a          =				model.generate(UpperCamelCase__				,  do_sample=UpperCamelCase__       )
            self.assertListEqual(output_ids[0].numpy().tolist()				,  UpperCamelCase__       )
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import warnings
  
  from ...utils import logging
  from .image_processing_vit import ViTImageProcessor
  
  
  __SCREAMING_SNAKE_CASE					=						logging.get_logger(__name__)
  
  
  
  
  
  class __snake_case		(					_SCREAMING_SNAKE_CASE      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     def __init__(		self							:Tuple				,  *UpperCamelCase__							:Tuple				,  **UpperCamelCase__							:Any       ):
            warnings.warn(
                "The class ViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
                " use ViTImageProcessor instead."				,  UpperCamelCase__				,  )
            super().__init__(*UpperCamelCase__				,  **UpperCamelCase__       )
  