


'''simple docstring'''


from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
     import PIL

__magic_name__			=      logging.get_logger(__name__)




def      lowerCamelCase					(      lowerCamelCase  :      str):
      if isinstance(lowerCamelCase							,						(list, tuple)) and isinstance(videos[0]							,						(list, tuple)) and is_valid_image(videos[0][0]):
            return videos

      elif isinstance(lowerCamelCase							,						(list, tuple)) and is_valid_image(videos[0]):
            return [videos]

      elif is_valid_image(lowerCamelCase):
            return [[videos]]

      raise ValueError(F'Could not make batched video from {videos}')






class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE    ):


  '''simple docstring'''







  a_  					=							["""pixel_values"""]






  def __init__(							self :       List[Any]	,_a :       bool = True	,_a :       Dict[str, int] = None	,_a :       PILImageResampling = PILImageResampling.BILINEAR	,_a :       bool = True	,_a :       Dict[str, int] = None	,_a :       bool = True	,_a :       Union[int, float] = 1 / 255	,_a :       bool = True	,_a :       bool = True	,_a :       Optional[Union[float, List[float]]] = None	,_a :       Optional[Union[float, List[float]]] = None	,**_a :       List[Any]	,):

        '''simple docstring'''




        super().__init__(**_a )
        A_						:  Union[str, Any]          =				size if size is not None else {"""shortest_edge""": 256}
        A_						:  Any          =				get_size_dict(_a	,default_to_square=_a )
        A_						:  List[str]          =				crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
        A_						:  str          =				get_size_dict(_a	,param_name="""crop_size""" )

        A_						:  Any          =				do_resize
        A_						:  List[str]          =				size
        A_						:  Optional[int]          =				do_center_crop
        A_						:  Dict          =				crop_size
        A_						:  str          =				resample
        A_						:  Tuple          =				do_rescale
        A_						:  int          =				rescale_factor
        A_						:  Dict          =				offset
        A_						:  Optional[Any]          =				do_normalize
        A_						:  Optional[int]          =				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        A_						:  List[str]          =				image_std if image_std is not None else IMAGENET_STANDARD_STD






  def        _a							(							self :       List[Any]	,_a :       np.ndarray	,_a :       Dict[str, int]	,_a :       PILImageResampling = PILImageResampling.BILINEAR	,_a :       Optional[Union[str, ChannelDimension]] = None	,**_a :       Dict	,):

        '''simple docstring'''




        A_						:  int          =				get_size_dict(_a	,default_to_square=_a )
        if "shortest_edge" in size:
              A_						:  Dict          =				get_resize_output_image_size(_a	,size["""shortest_edge"""]	,default_to_square=_a )
        elif "height" in size and "width" in size:
              A_						:  List[Any]          =				(size["""height"""], size["""width"""])
        else:
              raise ValueError(f'Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}' )
        return resize(_a	,size=_a	,resample=_a	,data_format=_a	,**_a )






  def        _a							(							self :       Any	,_a :       np.ndarray	,_a :       Dict[str, int]	,_a :       Optional[Union[str, ChannelDimension]] = None	,**_a :       List[Any]	,):

        '''simple docstring'''




        A_						:  Tuple          =				get_size_dict(_a )
        if "height" not in size or "width" not in size:
              raise ValueError(f'Size must have \'height\' and \'width\' as keys. Got {size.keys()}' )
        return center_crop(_a	,size=(size["""height"""], size["""width"""])	,data_format=_a	,**_a )






  def        _a							(							self :       int	,_a :       np.ndarray	,_a :       Union[int, float]	,_a :       bool = True	,_a :       Optional[Union[str, ChannelDimension]] = None	,**_a :       List[str]	,):

        '''simple docstring'''




        A_						:  Optional[int]          =				image.astype(np.floataa )
        if offset:
              A_						:  Optional[int]          =				image - (scale / 2)
        return rescale(_a	,scale=_a	,data_format=_a	,**_a )






  def        _a							(							self :       Optional[Any]	,_a :       np.ndarray	,_a :       Union[float, List[float]]	,_a :       Union[float, List[float]]	,_a :       Optional[Union[str, ChannelDimension]] = None	,**_a :       List[Any]	,):

        '''simple docstring'''




        return normalize(_a	,mean=_a	,std=_a	,data_format=_a	,**_a )






  def        _a							(							self :       Tuple	,_a :       ImageInput	,_a :       bool = None	,_a :       Dict[str, int] = None	,_a :       PILImageResampling = None	,_a :       bool = None	,_a :       Dict[str, int] = None	,_a :       bool = None	,_a :       float = None	,_a :       bool = None	,_a :       bool = None	,_a :       Optional[Union[float, List[float]]] = None	,_a :       Optional[Union[float, List[float]]] = None	,_a :       Optional[ChannelDimension] = ChannelDimension.FIRST	,):

        '''simple docstring'''




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

        if do_center_crop and crop_size is None:
              raise ValueError("""Crop size must be specified if do_center_crop is True.""" )

        if do_rescale and rescale_factor is None:
              raise ValueError("""Rescale factor must be specified if do_rescale 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.""" )

        if offset and not do_rescale:
              raise ValueError("""For offset, do_rescale must also be set to True.""" )

        # All transformations expect numpy arrays.
        A_						:  Optional[int]          =				to_numpy_array(_a )

        if do_resize:
              A_						:  Tuple          =				self.resize(image=_a	,size=_a	,resample=_a )

        if do_center_crop:
              A_						:  Optional[int]          =				self.center_crop(_a	,size=_a )

        if do_rescale:
              A_						:  Any          =				self.rescale(image=_a	,scale=_a	,offset=_a )

        if do_normalize:
              A_						:  Tuple          =				self.normalize(image=_a	,mean=_a	,std=_a )

        A_						:  int          =				to_channel_dimension_format(_a	,_a )
        return image






  def        _a							(							self :       int	,_a :       ImageInput	,_a :       bool = None	,_a :       Dict[str, int] = None	,_a :       PILImageResampling = None	,_a :       bool = None	,_a :       Dict[str, int] = None	,_a :       bool = None	,_a :       float = None	,_a :       bool = None	,_a :       bool = None	,_a :       Optional[Union[float, List[float]]] = None	,_a :       Optional[Union[float, List[float]]] = None	,_a :       Optional[Union[str, TensorType]] = None	,_a :       ChannelDimension = ChannelDimension.FIRST	,**_a :       List[Any]	,):

        '''simple docstring'''




        A_						:  str          =				do_resize if do_resize is not None else self.do_resize
        A_						:  Tuple          =				resample if resample is not None else self.resample
        A_						:  Any          =				do_center_crop if do_center_crop is not None else self.do_center_crop
        A_						:  Dict          =				do_rescale if do_rescale is not None else self.do_rescale
        A_						:  List[str]          =				rescale_factor if rescale_factor is not None else self.rescale_factor
        A_						:  int          =				offset if offset is not None else self.offset
        A_						:  List[str]          =				do_normalize if do_normalize is not None else self.do_normalize
        A_						:  Union[str, Any]          =				image_mean if image_mean is not None else self.image_mean
        A_						:  int          =				image_std if image_std is not None else self.image_std

        A_						:  str          =				size if size is not None else self.size
        A_						:  List[Any]          =				get_size_dict(_a	,default_to_square=_a )
        A_						:  Tuple          =				crop_size if crop_size is not None else self.crop_size
        A_						:  List[str]          =				get_size_dict(_a	,param_name="""crop_size""" )

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

        A_						:  List[Any]          =				make_batched(_a )

        A_						:  List[Any]          =				[
            [
                self._preprocess_image(
                    image=_a	,do_resize=_a	,size=_a	,resample=_a	,do_center_crop=_a	,crop_size=_a	,do_rescale=_a	,rescale_factor=_a	,offset=_a	,do_normalize=_a	,image_mean=_a	,image_std=_a	,data_format=_a	,)
                for img in video
            ]
            for video in videos
        ]

        A_						:  List[Any]          =				{"""pixel_values""": videos}
        return BatchFeature(data=_a	,tensor_type=_a )




'''simple docstring'''


import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
         OpenAIGPTConfig,
         OpenAIGPTDoubleHeadsModel,
         OpenAIGPTForSequenceClassification,
         OpenAIGPTLMHeadModel,
         OpenAIGPTModel,
     )



class 	__lowerCAmelCase		:


  '''simple docstring'''







  def __init__(							self :       Optional[int]	,_a :       List[Any]	,_a :       Dict=13	,_a :       List[Any]=7	,_a :       Optional[Any]=True	,_a :       Any=True	,_a :       Optional[int]=True	,_a :       Union[str, Any]=99	,_a :       Union[str, Any]=32	,_a :       List[str]=5	,_a :       List[str]=4	,_a :       Dict=37	,_a :       List[Any]="gelu"	,_a :       int=0.1	,_a :       Optional[int]=0.1	,_a :       Tuple=512	,_a :       Union[str, Any]=16	,_a :       Optional[Any]=2	,_a :       Optional[Any]=0.02	,_a :       Optional[int]=3	,_a :       str=4	,_a :       Optional[Any]=None	,):

        '''simple docstring'''




        A_						:  Optional[Any]          =				parent
        A_						:  str          =				batch_size
        A_						:  int          =				seq_length
        A_						:  Union[str, Any]          =				is_training
        A_						:  Optional[Any]          =				use_token_type_ids
        A_						:  int          =				use_labels
        A_						:  Dict          =				vocab_size
        A_						:  List[Any]          =				hidden_size
        A_						:  Tuple          =				num_hidden_layers
        A_						:  Optional[int]          =				num_attention_heads
        A_						:  int          =				intermediate_size
        A_						:  Tuple          =				hidden_act
        A_						:  int          =				hidden_dropout_prob
        A_						:  Dict          =				attention_probs_dropout_prob
        A_						:  Any          =				max_position_embeddings
        A_						:  Optional[Any]          =				type_vocab_size
        A_						:  Tuple          =				type_sequence_label_size
        A_						:  int          =				initializer_range
        A_						:  Optional[Any]          =				num_labels
        A_						:  str          =				num_choices
        A_						:  Optional[Any]          =				scope
        A_						:  List[Any]          =				self.vocab_size - 1






  def        _a							(							self :       Any ):

        '''simple docstring'''




        A_						:  List[Any]          =				ids_tensor([self.batch_size, self.seq_length]	,self.vocab_size )

        A_						:  List[Any]          =				None
        if self.use_token_type_ids:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size, self.seq_length]	,self.type_vocab_size )

        A_						:  int          =				None
        A_						:  str          =				None
        A_						:  Union[str, Any]          =				None
        if self.use_labels:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
              A_						:  str          =				ids_tensor([self.batch_size, self.seq_length]	,self.num_labels )
              A_						:  Any          =				ids_tensor([self.batch_size]	,self.num_choices )

        A_						:  List[Any]          =				OpenAIGPTConfig(
            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_						:  Tuple          =				ids_tensor([self.num_hidden_layers, self.num_attention_heads]	,2 )

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






  def        _a							(							self :       Optional[int]	,_a :       List[str]	,_a :       str	,_a :       int	,_a :       int	,*_a :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  Optional[Any]          =				OpenAIGPTModel(config=_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,head_mask=_a )
        A_						:  str          =				model(_a	,token_type_ids=_a )
        A_						:  Dict          =				model(_a )

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






  def        _a							(							self :       Dict	,_a :       Optional[int]	,_a :       Union[str, Any]	,_a :       Dict	,_a :       List[str]	,*_a :       str ):

        '''simple docstring'''




        A_						:  str          =				OpenAIGPTLMHeadModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Any          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       Any	,_a :       Dict	,_a :       List[Any]	,_a :       Dict	,_a :       Union[str, Any]	,*_a :       str ):

        '''simple docstring'''




        A_						:  Any          =				OpenAIGPTDoubleHeadsModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       List[str]	,_a :       str	,_a :       Tuple	,_a :       Dict	,_a :       Tuple	,*_a :       Dict ):

        '''simple docstring'''




        A_						:  List[str]          =				self.num_labels
        A_						:  int          =				OpenAIGPTForSequenceClassification(_a )
        model.to(_a )
        model.eval()

        A_						:  Dict          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
        A_						:  Optional[Any]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels) )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Union[str, Any]          =				self.prepare_config_and_inputs()
        (
            (
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					
        )						:  str          =				config_and_inputs
        A_						:  int          =				{
            """input_ids""": input_ids,
            """token_type_ids""": token_type_ids,
            """head_mask""": head_mask,
        }

        return config, inputs_dict







@require_torch
class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , unittest.TestCase    ):


  '''simple docstring'''







  a_  					=							(
      (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
      if is_torch_available()
      else ()
  )
  a_  					=							(
      (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
  )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
  a_  					=							(
      {
          """feature-extraction""": OpenAIGPTModel,
          """text-classification""": OpenAIGPTForSequenceClassification,
          """text-generation""": OpenAIGPTLMHeadModel,
          """zero-shot""": OpenAIGPTForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )






  def        _a							(							self :       Tuple	,_a :       Optional[int]	,_a :       str	,_a :       List[str]	,_a :       List[str]	,_a :       Any ):

        '''simple docstring'''




        if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
              # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
              # `OpenAIGPTConfig` 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 :       Optional[int]	,_a :       str	,_a :       Dict	,_a :       Optional[int]=False ):

        '''simple docstring'''




        A_						:  Any          =				super()._prepare_for_class(_a	,_a	,return_labels=_a )

        if return_labels:
              if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
                    A_						:  Union[str, Any]          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)	,dtype=torch.long	,device=_a	,)
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Tuple          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices)	,dtype=torch.long	,device=_a	,)
                    A_						:  int          =				torch.zeros(
                        self.model_tester.batch_size	,dtype=torch.long	,device=_a )
        return inputs_dict






  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  Tuple          =				OpenAIGPTModelTester(self )
        A_						:  Optional[int]          =				ConfigTester(self	,config_class=_a	,n_embd=37 )






  def        _a							(							self :       Any ):

        '''simple docstring'''




        self.config_tester.run_common_tests()






  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        A_						:  int          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_model(*_a )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Dict          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_lm_head_model(*_a )






  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        A_						:  str          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_double_lm_head_model(*_a )






  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  List[Any]          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_a )






  @slow
  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A_						:  Union[str, Any]          =				OpenAIGPTModel.from_pretrained(_a )
              self.assertIsNotNone(_a )







@require_torch
class 	__lowerCAmelCase		(							unittest.TestCase    ):


  '''simple docstring'''







  @slow
  def        _a							(							self :       List[str] ):

        '''simple docstring'''




        A_						:  Dict          =				OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt""" )
        model.to(_a )
        A_						:  Dict          =				torch.tensor([[481, 4735, 544]]	,dtype=torch.long	,device=_a )  # the president is
        A_						:  Dict          =				[
            481,
            4735,
            544,
            246,
            963,
            870,
            762,
            239,
            244,
            40477,
            244,
            249,
            719,
            881,
            487,
            544,
            240,
            244,
            603,
            481,
        ]  # the president is a very good man. " \n " i\'m sure he is, " said the

        A_						:  int          =				model.generate(_a	,do_sample=_a )
        self.assertListEqual(output_ids[0].tolist()	,_a )
