



'''simple docstring'''






import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class 				lowercase			(    _lowerCamelCase							):


 """simple docstring"""


 UpperCAmelCase		      =    ["""image_processor""", """tokenizer"""]
 UpperCAmelCase		      =    """LayoutLMv2ImageProcessor"""
 UpperCAmelCase		      =    ("""LayoutLMv2Tokenizer""", """LayoutLMv2TokenizerFast""")







 def __init__(				self    ,a_=None    ,a_=None    ,**a_				)						->  Tuple:
        _UpperCAmelCase    :		List[Any]     	=					None
        if "feature_extractor" in kwargs:
               warnings.warn(
                   """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
                   """ instead."""    ,a_    ,)
               _UpperCAmelCase    :		Tuple     	=					kwargs.pop("""feature_extractor"""				)

        _UpperCAmelCase    :		Any     	=					image_processor if image_processor is not None else feature_extractor
        if image_processor is None:
               raise ValueError("""You need to specify an `image_processor`."""				)
        if tokenizer is None:
               raise ValueError("""You need to specify a `tokenizer`."""				)

        super().__init__(a_    ,a_				)







 def __call__(				self    ,a_    ,a_ = None    ,a_ = None    ,a_ = None    ,a_ = None    ,a_ = True    ,a_ = False    ,a_ = False    ,a_ = None    ,a_ = 0    ,a_ = None    ,a_ = None    ,a_ = None    ,a_ = False    ,a_ = False    ,a_ = False    ,a_ = False    ,a_ = True    ,a_ = None    ,**a_    ,)						->  BatchEncoding:
        # verify input
        if self.image_processor.apply_ocr and (boxes is not None):
               raise ValueError(
                   """You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True."""				)

        if self.image_processor.apply_ocr and (word_labels is not None):
               raise ValueError(
                   """You cannot provide word labels if you initialized the image processor with apply_ocr set to True."""				)

        if return_overflowing_tokens is True and return_offsets_mapping is False:
               raise ValueError("""You cannot return overflowing tokens without returning the offsets mapping."""				)

        # first, apply the image processor
        _UpperCAmelCase    :		Tuple     	=					self.image_processor(images=a_    ,return_tensors=a_				)

        # second, apply the tokenizer
        if text is not None and self.image_processor.apply_ocr and text_pair is None:
               if isinstance(a_    ,a_				):
                      _UpperCAmelCase    :		Union[str, Any]     	=					[text]  # add batch dimension (as the image processor always adds a batch dimension)
               _UpperCAmelCase    :		List[str]     	=					features["""words"""]

        _UpperCAmelCase    :		int     	=					self.tokenizer(
            text=text if text is not None else features["""words"""]    ,text_pair=text_pair if text_pair is not None else None    ,boxes=boxes if boxes is not None else features["""boxes"""]    ,word_labels=a_    ,add_special_tokens=a_    ,padding=a_    ,truncation=a_    ,max_length=a_    ,stride=a_    ,pad_to_multiple_of=a_    ,return_token_type_ids=a_    ,return_attention_mask=a_    ,return_overflowing_tokens=a_    ,return_special_tokens_mask=a_    ,return_offsets_mapping=a_    ,return_length=a_    ,verbose=a_    ,return_tensors=a_    ,**a_    ,)

        # add pixel values
        _UpperCAmelCase    :		int     	=					features.pop("""pixel_values"""				)
        if return_overflowing_tokens is True:
               _UpperCAmelCase    :		Any     	=					self.get_overflowing_images(a_    ,encoded_inputs["""overflow_to_sample_mapping"""]				)
        _UpperCAmelCase    :		List[str]     	=					images

        return encoded_inputs







 def _snake_case					(				self    ,a_    ,a_				)						->  str:
        # in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
        _UpperCAmelCase    :		Optional[int]     	=					[]
        for sample_idx in overflow_to_sample_mapping:
               images_with_overflow.append(images[sample_idx]				)

        if len(a_				) != len(a_				):
               raise ValueError(
                   """Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"""
                   f''' {len(a_				)} and {len(a_				)}'''				)

        return images_with_overflow







 def _snake_case					(				self    ,*a_    ,**a_				)						->  Union[str, Any]:
        return self.tokenizer.batch_decode(*a_    ,**a_				)







 def _snake_case					(				self    ,*a_    ,**a_				)						->  Dict:
        return self.tokenizer.decode(*a_    ,**a_				)







 @property
 def _snake_case					(				self				)						->  Optional[int]:
        return ["input_ids", "bbox", "token_type_ids", "attention_mask", "image"]







 @property
 def _snake_case					(				self				)						->  Union[str, Any]:
        warnings.warn(
            """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""    ,a_    ,)
        return self.image_processor_class







 @property
 def _snake_case					(				self				)						->  List[str]:
        warnings.warn(
            """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""    ,a_    ,)
        return self.image_processor




'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, 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.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )




class       __UpperCAmelCase							:





       '''simple docstring'''



       def __init__( self       ,	_SCREAMING_SNAKE_CASE       ,	)						->	Any:
           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    __A			( self					)						->	Union[str, Any]:
           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_      =  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_      =  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					)						->	Optional[int]:
           A_      =  TFOpenAIGPTModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  [input_ids, input_mask]
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  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					)						->	Dict:
           A_      =  TFOpenAIGPTLMHeadModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  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       ,	*_SCREAMING_SNAKE_CASE					)						->	Optional[Any]:
           A_      =  TFOpenAIGPTDoubleHeadsModel(config=_SCREAMING_SNAKE_CASE					)

           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)

           A_      =  {
               '''input_ids''': multiple_choice_inputs_ids,
               '''mc_token_ids''': mc_token_ids,
               '''attention_mask''': multiple_choice_input_mask,
               '''token_type_ids''': multiple_choice_token_type_ids,
           }
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(
               result.logits.shape       ,	(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)					)
           self.parent.assertEqual(result.mc_logits.shape       ,	(self.batch_size, self.num_choices)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  self.num_labels
           A_      =  ids_tensor([self.batch_size]       ,	self.type_sequence_label_size					)
           A_      =  {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
               '''labels''': sequence_labels,
           }
           A_      =  TFOpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE					)
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)					)

       def    __A			( self					)						->	Union[str, 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       __UpperCAmelCase							(							_UpperCamelCase		, _UpperCamelCase		, unittest.TestCase	):





       '''simple docstring'''



       __lowercase   :   Dict  					=							(
           (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
           if is_tf_available()
           else ()
       )
       __lowercase   :   List[str]  					=							(
           (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
       __lowercase   :   List[str]  					=							(
           {
               'feature-extraction': TFOpenAIGPTModel,
               'text-classification': TFOpenAIGPTForSequenceClassification,
               'text-generation': TFOpenAIGPTLMHeadModel,
               'zero-shot': TFOpenAIGPTForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase   :   Dict  					=							False
       __lowercase   :   Optional[int]  					=							False

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					)						->	Union[str, Any]:
           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					)						->	Any:
           A_      =  TFOpenAIGPTModelTester(self					)
           A_      =  ConfigTester(self       ,	config_class=_SCREAMING_SNAKE_CASE       ,	n_embd=37					)

       def    __A			( self					)						->	List[Any]:
           self.config_tester.run_common_tests()

       def    __A			( self					)						->	Dict:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Any:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_lm_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Tuple:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_double_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[str]:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE					)

       @slow
       def    __A			( self					)						->	Union[str, Any]:
           for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               A_      =  TFOpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE					)
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE					)




@require_tf
class       __UpperCAmelCase							(							unittest.TestCase	):





       '''simple docstring'''



       @slow
       def    __A			( self					)						->	List[str]:
           A_      =  TFOpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''					)
           A_      =  tf.convert_to_tensor([[481, 4735, 544]]       ,	dtype=tf.intaa					)  # the president is
           A_      =  [
               481,
               4735,
               544,
               246,
               963,
               870,
               762,
               239,
               244,
               4_0477,
               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_      =  model.generate(_SCREAMING_SNAKE_CASE       ,	do_sample=_SCREAMING_SNAKE_CASE					)
           self.assertListEqual(output_ids[0].numpy().tolist()       ,	_SCREAMING_SNAKE_CASE					)






