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"""
  
  
  
  
  # Copyright 2022 The HuggingFace Team. All rights reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  import os
  from typing import List
  
  
  
  def 						__a      (  a,		a					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         if name != "training_function" and name != "main":
                raise ValueError(F'Incorrect function name passed: {name}, choose either \'main\' or \'training_function\''					)
         _a   , _a          =				[], False
         for line in lines:
                if not found_start and F'def {name}' in line:
                       _a          =				True
                       good_lines.append(a					)
                       continue
                if found_start:
                       if name == "training_function" and "def main" in line:
                              return good_lines
                       if name == "main" and "if __name__" in line:
                              return good_lines
                       good_lines.append(a					)
  
  
  
  def 						__a      (  a					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         return [line for line in lines if not line.lstrip().startswith("#"					) and line != "\n"]
  
  
  
  def 						__a      (  a,		a,		a,		a = None					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         with open(a,		"r"					) as f:
                _a          =				f.readlines()
         with open(os.path.abspath(os.path.join("examples",		"nlp_example.py"					)					),		"r"					) as f:
                _a          =				f.readlines()
         with open(a,		"r"					) as f:
                _a          =				f.readlines()
         if secondary_filename is not None:
                with open(a,		"r"					) as f:
                       _a          =				f.readlines()
  
      # This is our base, we remove all the code from here in our `full_filename` and `feature_filename` to find the new content
         if parser_only:
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                if secondary_filename is not None:
                       _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
         else:
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                if secondary_filename is not None:
                       _a          =				clean_lines(
                           get_function_contents_by_name(a,		"training_function"					)					)
  
         _a          =				"train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\n"
  
         # Specific code in our script that differs from the full version, aka what is new
         _a          =				[]
         _a          =				[]  # We keep track of the idxs just in case it's a repeated statement
         _a          =				iter(a					)
         for i in range(len(a					) - 1					):
                if i not in passed_idxs:
                       _a          =				next(a					)
                       if (line not in full_file_func) and (line.lstrip() != _dl_line):
                              if "TESTING_MOCKED_DATALOADERS" not in line:
                                     new_feature_code.append(a					)
                                     passed_idxs.append(a					)
                              else:
                                     # Skip over the `config['num_epochs'] = 2` statement
                                     _a          =				next(a					)
  
      # Extract out just the new parts from the full_file_training_func
         _a          =				[]
         _a          =				[]  # We keep track of the idxs just in case it's a repeated statement
         for i, line in enumerate(a					):
                if i not in passed_idxs:
                       if (line not in full_file_func) and (line.lstrip() != _dl_line):
                              if "TESTING_MOCKED_DATALOADERS" not in line:
                                     new_full_example_parts.append(a					)
                                     passed_idxs.append(a					)
  
      # Finally, get the overall diff
         _a          =				[line for line in new_feature_code if line not in new_full_example_parts]
         if secondary_filename is not None:
                _a          =				[line for line in full_file_contents if line not in secondary_file_func]
                _a          =				[line for line in diff_from_example if line not in diff_from_two]
  
         return diff_from_example
  