
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


_SCREAMING_SNAKE_CASE     :   Dict							 =      logging.get_logger(__name__)


if is_vision_available():
					import PIL







class 			UpperCamelCase__		(     SCREAMING_SNAKE_CASE_ ):







	'''simple docstring'''
	_lowerCAmelCase											=					["pixel_values"]





	def __init__(      self					,							UpperCamelCase__ = True					,							UpperCamelCase__ = None					,							UpperCamelCase__ = PILImageResampling.BILINEAR					,							UpperCamelCase__ = True					,							UpperCamelCase__ = False					,							UpperCamelCase__ = True					,							UpperCamelCase__ = True					,							UpperCamelCase__ = 1 / 255					,							UpperCamelCase__ = True					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							**UpperCamelCase__					,							):
					super().__init__(**_SCREAMING_SNAKE_CASE		)

					A__	:						Optional[Any]								=				size if size is not None else {'''height''': 2560, '''width''': 1920}
					if isinstance(_SCREAMING_SNAKE_CASE					,							(tuple, list)		):
									# The previous feature extractor size parameter was in (width, height) format
									A__	:						str								=				size[::-1]
					A__	:						Optional[int]								=				get_size_dict(_SCREAMING_SNAKE_CASE		)

					A__	:						List[Any]								=				do_resize
					A__	:						int								=				size
					A__	:						Optional[int]								=				resample
					A__	:						str								=				do_thumbnail
					A__	:						Any								=				do_align_long_axis
					A__	:						int								=				do_pad
					A__	:						Optional[int]								=				do_rescale
					A__	:						Tuple								=				rescale_factor
					A__	:						Any								=				do_normalize
					A__	:						Dict								=				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
					A__	:						str								=				image_std if image_std is not None else IMAGENET_STANDARD_STD





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = None		):
					A__							,				A__	:						List[Any]								=				get_image_size(_SCREAMING_SNAKE_CASE		)
					A__							,				A__	:						Optional[Any]								=				size['''height'''], size['''width''']

					if (output_width < output_height and input_width > input_height) or (
					    output_width > output_height and input_width < input_height
					):
									A__	:						Dict								=				np.rotaa(_SCREAMING_SNAKE_CASE					,							3		)

					if data_format is not None:
									A__	:						Optional[int]								=				to_channel_dimension_format(_SCREAMING_SNAKE_CASE					,							_SCREAMING_SNAKE_CASE		)

					return image





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = False					,							UpperCamelCase__ = None					,							):
					A__							,				A__	:						Optional[Any]								=				size['''height'''], size['''width''']
					A__							,				A__	:						List[Any]								=				get_image_size(_SCREAMING_SNAKE_CASE		)

					A__	:						Tuple								=				output_width - input_width
					A__	:						Optional[Any]								=				output_height - input_height

					if random_padding:
									A__	:						Any								=				np.random.randint(low=0					,							high=delta_height + 1		)
									A__	:						str								=				np.random.randint(low=0					,							high=delta_width + 1		)
					else:
									A__	:						Union[str, Any]								=				delta_height // 2
									A__	:						int								=				delta_width // 2

					A__	:						Union[str, Any]								=				delta_height - pad_top
					A__	:						Optional[Any]								=				delta_width - pad_left

					A__	:						Dict								=				((pad_top, pad_bottom), (pad_left, pad_right))
					return pad(_SCREAMING_SNAKE_CASE					,							_SCREAMING_SNAKE_CASE					,							data_format=_SCREAMING_SNAKE_CASE		)





	def 	__snake_case					(      self					,							*UpperCamelCase__					,							**UpperCamelCase__		):
					logger.info('''pad is deprecated and will be removed in version 4.27. Please use pad_image instead.'''		)
					return self.pad_image(*_SCREAMING_SNAKE_CASE					,							**_SCREAMING_SNAKE_CASE		)





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = PILImageResampling.BICUBIC					,							UpperCamelCase__ = None					,							**UpperCamelCase__					,							):
					A__							,				A__	:						Dict								=				get_image_size(_SCREAMING_SNAKE_CASE		)
					A__							,				A__	:						Any								=				size['''height'''], size['''width''']

					# We always resize to the smallest of either the input or output size.
					A__	:						List[str]								=				min(_SCREAMING_SNAKE_CASE					,							_SCREAMING_SNAKE_CASE		)
					A__	:						Union[str, Any]								=				min(_SCREAMING_SNAKE_CASE					,							_SCREAMING_SNAKE_CASE		)

					if height == input_height and width == input_width:
									return image

					if input_height > input_width:
									A__	:						Dict								=				int(input_width * height / input_height		)
					elif input_width > input_height:
									A__	:						Any								=				int(input_height * width / input_width		)

					return resize(
					    _SCREAMING_SNAKE_CASE					,							size=(height, width)					,							resample=_SCREAMING_SNAKE_CASE					,							reducing_gap=2.0					,							data_format=_SCREAMING_SNAKE_CASE					,							**_SCREAMING_SNAKE_CASE		)





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = PILImageResampling.BICUBIC					,							UpperCamelCase__ = None					,							**UpperCamelCase__					,							):
					A__	:						int								=				get_size_dict(_SCREAMING_SNAKE_CASE		)
					A__	:						int								=				min(size['''height''']					,							size['''width''']		)
					A__	:						Tuple								=				get_resize_output_image_size(_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE					,							default_to_square=_SCREAMING_SNAKE_CASE		)
					A__	:						Union[str, Any]								=				resize(_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE					,							resample=_SCREAMING_SNAKE_CASE					,							data_format=_SCREAMING_SNAKE_CASE					,							**_SCREAMING_SNAKE_CASE		)
					return resized_image





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = None					,							**UpperCamelCase__					,							):
					return rescale(_SCREAMING_SNAKE_CASE					,							scale=_SCREAMING_SNAKE_CASE					,							data_format=_SCREAMING_SNAKE_CASE					,							**_SCREAMING_SNAKE_CASE		)





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__					,							UpperCamelCase__ = None					,							**UpperCamelCase__					,							):
					return normalize(_SCREAMING_SNAKE_CASE					,							mean=_SCREAMING_SNAKE_CASE					,							std=_SCREAMING_SNAKE_CASE					,							data_format=_SCREAMING_SNAKE_CASE					,							**_SCREAMING_SNAKE_CASE		)





	def 	__snake_case					(      self					,							UpperCamelCase__					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = False					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = None					,							UpperCamelCase__ = ChannelDimension.FIRST					,							**UpperCamelCase__					,							):
					A__	:						Tuple								=				do_resize if do_resize is not None else self.do_resize
					A__	:						List[Any]								=				size if size is not None else self.size
					if isinstance(_SCREAMING_SNAKE_CASE					,							(tuple, list)		):
									# Previous feature extractor had size in (width, height) format
									A__	:						Union[str, Any]								=				size[::-1]
					A__	:						Optional[Any]								=				get_size_dict(_SCREAMING_SNAKE_CASE		)
					A__	:						Union[str, Any]								=				resample if resample is not None else self.resample
					A__	:						Tuple								=				do_thumbnail if do_thumbnail is not None else self.do_thumbnail
					A__	:						Dict								=				do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
					A__	:						List[str]								=				do_pad if do_pad is not None else self.do_pad
					A__	:						Union[str, Any]								=				do_rescale if do_rescale is not None else self.do_rescale
					A__	:						Optional[int]								=				rescale_factor if rescale_factor is not None else self.rescale_factor
					A__	:						Dict								=				do_normalize if do_normalize is not None else self.do_normalize
					A__	:						List[str]								=				image_mean if image_mean is not None else self.image_mean
					A__	:						Tuple								=				image_std if image_std is not None else self.image_std

					A__	:						Union[str, Any]								=				make_list_of_images(_SCREAMING_SNAKE_CASE		)

					if not valid_images(_SCREAMING_SNAKE_CASE		):
									raise ValueError(
									    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
									    '''torch.Tensor, tf.Tensor or jax.ndarray.'''		)

					if do_resize and size is None:
									raise ValueError('''Size must be specified if do_resize is True.'''		)

					if do_rescale and rescale_factor is None:
									raise ValueError('''Rescale factor must be specified if do_rescale is True.'''		)

					if do_pad and size is None:
									raise ValueError('''Size must be specified if do_pad is True.'''		)

					if do_normalize and (image_mean is None or image_std is None):
									raise ValueError('''Image mean and std must be specified if do_normalize is True.'''		)

					# All transformations expect numpy arrays.
					A__	:						Tuple								=				[to_numpy_array(_SCREAMING_SNAKE_CASE		) for image in images]

					if do_align_long_axis:
									A__	:						Optional[int]								=				[self.align_long_axis(_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE		) for image in images]

					if do_resize:
									A__	:						Any								=				[self.resize(image=_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE					,							resample=_SCREAMING_SNAKE_CASE		) for image in images]

					if do_thumbnail:
									A__	:						Optional[Any]								=				[self.thumbnail(image=_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE		) for image in images]

					if do_pad:
									A__	:						Optional[Any]								=				[self.pad_image(image=_SCREAMING_SNAKE_CASE					,							size=_SCREAMING_SNAKE_CASE					,							random_padding=_SCREAMING_SNAKE_CASE		) for image in images]

					if do_rescale:
									A__	:						Union[str, Any]								=				[self.rescale(image=_SCREAMING_SNAKE_CASE					,							scale=_SCREAMING_SNAKE_CASE		) for image in images]

					if do_normalize:
									A__	:						Optional[int]								=				[self.normalize(image=_SCREAMING_SNAKE_CASE					,							mean=_SCREAMING_SNAKE_CASE					,							std=_SCREAMING_SNAKE_CASE		) for image in images]

					A__	:						Tuple								=				[to_channel_dimension_format(_SCREAMING_SNAKE_CASE					,							_SCREAMING_SNAKE_CASE		) for image in images]

					A__	:						str								=				{'''pixel_values''': images}
					return BatchFeature(data=_SCREAMING_SNAKE_CASE					,							tensor_type=_SCREAMING_SNAKE_CASE		)
"""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	:							Union[str, Any]    =    (TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
   __UpperCAmelCase	:							List[str]    =    (TFCTRLLMHeadModel,) if is_tf_available() else ()
   __UpperCAmelCase	:							Dict    =    (
       {
           "feature-extraction": TFCTRLModel,
           "text-classification": TFCTRLForSequenceClassification,
           "text-generation": TFCTRLLMHeadModel,
           "zero-shot": TFCTRLForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __UpperCAmelCase	:							str    =    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	)






