


from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import DeiTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import (
       TFDeiTForImageClassification,
       TFDeiTForImageClassificationWithTeacher,
       TFDeiTForMaskedImageModeling,
       TFDeiTModel,
   )
   from transformers.models.deit.modeling_tf_deit import TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import DeiTImageProcessor





class  lowerCAmelCase__:






    '''simple docstring'''





    def __init__(	self				:   Any       ,   __snake_case				:   int       ,   __snake_case				:   Tuple=13       ,   __snake_case				:   Any=30       ,   __snake_case				:   Union[str, Any]=2       ,   __snake_case				:   Optional[int]=3       ,   __snake_case				:   Any=True       ,   __snake_case				:   Union[str, Any]=True       ,   __snake_case				:   Optional[int]=32       ,   __snake_case				:   Optional[Any]=2       ,   __snake_case				:   List[Any]=4       ,   __snake_case				:   List[str]=37       ,   __snake_case				:   Tuple="gelu"       ,   __snake_case				:   Optional[Any]=0.1       ,   __snake_case				:   Optional[Any]=0.1       ,   __snake_case				:   Optional[Any]=10       ,   __snake_case				:   str=0.02       ,   __snake_case				:   Dict=3       ,   __snake_case				:   int=None       ,   __snake_case				:   Union[str, Any]=2       ,   ):





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   parent
       UpperCAmelCase_							:      int						=   batch_size
       UpperCAmelCase_							:      Optional[int]						=   image_size
       UpperCAmelCase_							:      Optional[Any]						=   patch_size
       UpperCAmelCase_							:      Optional[int]						=   num_channels
       UpperCAmelCase_							:      Dict						=   is_training
       UpperCAmelCase_							:      List[Any]						=   use_labels
       UpperCAmelCase_							:      List[Any]						=   hidden_size
       UpperCAmelCase_							:      Optional[int]						=   num_hidden_layers
       UpperCAmelCase_							:      int						=   num_attention_heads
       UpperCAmelCase_							:      Tuple						=   intermediate_size
       UpperCAmelCase_							:      Union[str, Any]						=   hidden_act
       UpperCAmelCase_							:      Any						=   hidden_dropout_prob
       UpperCAmelCase_							:      Dict						=   attention_probs_dropout_prob
       UpperCAmelCase_							:      Tuple						=   type_sequence_label_size
       UpperCAmelCase_							:      Dict						=   initializer_range
       UpperCAmelCase_							:      Optional[int]						=   scope
       UpperCAmelCase_							:      Union[str, Any]						=   encoder_stride

       # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
       UpperCAmelCase_							:      Tuple						=   (image_size // patch_size) ** 2
       UpperCAmelCase_							:      Union[str, Any]						=   num_patches + 2





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





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

       UpperCAmelCase_							:      str						=   None
       if self.use_labels:
          UpperCAmelCase_							:      str						=   ids_tensor([self.batch_size]       ,   self.type_sequence_label_size	)

       UpperCAmelCase_							:      List[Any]						=   self.get_config()

       return config, pixel_values, labels





    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       return DeiTConfig(
           image_size=self.image_size       ,   patch_size=self.patch_size       ,   num_channels=self.num_channels       ,   hidden_size=self.hidden_size       ,   num_hidden_layers=self.num_hidden_layers       ,   num_attention_heads=self.num_attention_heads       ,   intermediate_size=self.intermediate_size       ,   hidden_act=self.hidden_act       ,   hidden_dropout_prob=self.hidden_dropout_prob       ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,   is_decoder=__snake_case       ,   initializer_range=self.initializer_range       ,   encoder_stride=self.encoder_stride       ,   )





    def 					_lowerCamelCase (	self				:   List[Any]       ,   __snake_case				:   int       ,   __snake_case				:   Tuple       ,   __snake_case				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   TFDeiTModel(config=__snake_case	)
       UpperCAmelCase_							:      Union[str, Any]						=   model(__snake_case	)
       self.parent.assertEqual(result.last_hidden_state.shape       ,   (self.batch_size, self.seq_length, self.hidden_size)	)





    def 					_lowerCamelCase (	self				:   Optional[Any]       ,   __snake_case				:   int       ,   __snake_case				:   Tuple       ,   __snake_case				:   Any	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   TFDeiTForMaskedImageModeling(config=__snake_case	)
       UpperCAmelCase_							:      str						=   model(__snake_case	)
       self.parent.assertEqual(
           result.reconstruction.shape       ,   (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

       # test greyscale images
       UpperCAmelCase_							:      str						=   1
       UpperCAmelCase_							:      str						=   TFDeiTForMaskedImageModeling(__snake_case	)

       UpperCAmelCase_							:      List[str]						=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
       UpperCAmelCase_							:      Any						=   model(__snake_case	)
       self.parent.assertEqual(result.reconstruction.shape       ,   (self.batch_size, 1, self.image_size, self.image_size)	)





    def 					_lowerCamelCase (	self				:   Dict       ,   __snake_case				:   List[Any]       ,   __snake_case				:   Optional[int]       ,   __snake_case				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   self.type_sequence_label_size
       UpperCAmelCase_							:      Dict						=   TFDeiTForImageClassification(__snake_case	)
       UpperCAmelCase_							:      Tuple						=   model(__snake_case       ,   labels=__snake_case	)
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.type_sequence_label_size)	)

       # test greyscale images
       UpperCAmelCase_							:      List[str]						=   1
       UpperCAmelCase_							:      Union[str, Any]						=   TFDeiTForImageClassification(__snake_case	)

       UpperCAmelCase_							:      Union[str, Any]						=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
       UpperCAmelCase_							:      List[Any]						=   model(__snake_case       ,   labels=__snake_case	)
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.type_sequence_label_size)	)





    def 					_lowerCamelCase (	self				:   List[str]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Union[str, Any]						=   self.prepare_config_and_inputs()
       UpperCAmelCase_							:      Any						=   config_and_inputs
       UpperCAmelCase_							:      Dict						=   {'pixel_values': pixel_values}
       return config, inputs_dict





@require_tf
class  lowerCAmelCase__(    __A    ,    __A    ,    unittest.TestCase						):






    '''simple docstring'''





    A_  :     Tuple			= (
        (
            TFDeiTModel,
            TFDeiTForImageClassification,
            TFDeiTForImageClassificationWithTeacher,
            TFDeiTForMaskedImageModeling,
        )
        if is_tf_available()
        else ()
    )
    A_  :     Tuple			= (
        {
            'feature-extraction': TFDeiTModel,
            'image-classification': (TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher),
        }
        if is_tf_available()
        else {}
    )

    A_  :     str			= False
    A_  :     List[Any]			= False
    A_  :     int			= False
    A_  :     Union[str, Any]			= False





    def 					_lowerCamelCase (	self				:   List[str]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   TFDeiTModelTester(self	)
       UpperCAmelCase_							:      Optional[Any]						=   ConfigTester(self       ,   config_class=__snake_case       ,   has_text_modality=__snake_case       ,   hidden_size=37	)





    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''
       self.config_tester.run_common_tests()





    @unittest.skip(reason='''DeiT does not use inputs_embeds'''	)
    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       pass





    def 					_lowerCamelCase (	self				:   str	):





       '''simple docstring'''
       UpperCAmelCase_							:      str						=   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          UpperCAmelCase_							:      Union[str, Any]						=   model_class(__snake_case	)
          self.assertIsInstance(model.get_input_embeddings()       ,   (tf.keras.layers.Layer)	)
          UpperCAmelCase_							:      str						=   model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(__snake_case       ,   tf.keras.layers.Dense	)	)





    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      Any						=   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          UpperCAmelCase_							:      List[Any]						=   model_class(__snake_case	)
          UpperCAmelCase_							:      str						=   inspect.signature(model.call	)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          UpperCAmelCase_							:      List[Any]						=   [*signature.parameters.keys()]

          UpperCAmelCase_							:      List[Any]						=   ['pixel_values']
          self.assertListEqual(arg_names[:1]       ,   __snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[int]	):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__snake_case	)





    def 					_lowerCamelCase (	self				:   List[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Dict	):





       '''simple docstring'''
       UpperCAmelCase_							:      Any						=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[Any]       ,   __snake_case				:   Tuple       ,   __snake_case				:   Dict       ,   __snake_case				:   List[Any]=False	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[str]						=   super()._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case	)

       if return_labels:
          if "labels" in inputs_dict and "labels" not in inspect.signature(model_class.call	).parameters:
             del inputs_dict["labels"]

       return inputs_dict





    @slow
    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''





       for model_name in TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          UpperCAmelCase_							:      Optional[int]						=   TFDeiTModel.from_pretrained(__snake_case	)
          self.assertIsNotNone(__snake_case	)





def      snake_case_						( ):
   UpperCAmelCase_							:      Any						=   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
   return image





@require_tf
@require_vision
class  lowerCAmelCase__(    unittest.TestCase						):






    '''simple docstring'''





    @cached_property
    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       return (
           DeiTImageProcessor.from_pretrained('''facebook/deit-base-distilled-patch16-224'''	)
           if is_vision_available()
           else None
       )





    @slow
    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   TFDeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''	)

       UpperCAmelCase_							:      Union[str, Any]						=   self.default_image_processor
       UpperCAmelCase_							:      List[Any]						=   prepare_img()
       UpperCAmelCase_							:      Any						=   image_processor(images=__snake_case       ,   return_tensors='''tf'''	)

       # forward pass
       UpperCAmelCase_							:      Optional[Any]						=   model(**__snake_case	)

       # verify the logits
       UpperCAmelCase_							:      str						=   tf.TensorShape((1, 1_000)	)
       self.assertEqual(outputs.logits.shape       ,   __snake_case	)

       UpperCAmelCase_							:      Tuple						=   tf.constant([-1.0_266, 0.1_912, -1.2_861]	)

       self.assertTrue(np.allclose(outputs.logits[0, :3]       ,   __snake_case       ,   atol=1E-4	)	)



import os
import re
import warnings
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
       from .tokenization_ta import TaTokenizer
else:
       __UpperCamelCase				:  Optional[int]      					=							None


__UpperCamelCase				:  Union[str, Any]      					=							logging.get_logger(__name__)

__UpperCamelCase				:  List[Any]      					=							{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

__UpperCamelCase				:  Optional[int]      					=							{
    'vocab_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/spiece.model',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/spiece.model',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/spiece.model',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/spiece.model',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/spiece.model',
    },
    'tokenizer_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/tokenizer.json',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/tokenizer.json',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/tokenizer.json',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/tokenizer.json',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/tokenizer.json',
    },
}


# TODO(PVP) - this should be removed in Transformers v5
__UpperCamelCase				:  Optional[Any]      					=							{
    't5-small': 512,
    't5-base': 512,
    't5-large': 512,
    't5-3b': 512,
    't5-11b': 512,
}





class  lowerCAmelCase__(    snake_case__						):






    '''simple docstring'''





    A_  :     Optional[int]			= VOCAB_FILES_NAMES
    A_  :     List[Any]			= PRETRAINED_VOCAB_FILES_MAP
    A_  :     int			= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    A_  :     str			= ['input_ids', 'attention_mask']
    A_  :     int			= TaTokenizer

    A_  :     List[int]			= []





    def __init__(	self				:   Union[str, Any]       ,   __snake_case				:   Tuple=None       ,   __snake_case				:   List[Any]=None       ,   __snake_case				:   int="</s>"       ,   __snake_case				:   List[Any]="<unk>"       ,   __snake_case				:   Dict="<pad>"       ,   __snake_case				:   Tuple=100       ,   __snake_case				:   int=None       ,   **__snake_case				:   Any       ,   ):





       '''simple docstring'''
       # Add extra_ids to the special token list
       if extra_ids > 0 and additional_special_tokens is None:
          UpperCAmelCase_							:      Optional[int]						=   [f'''<extra_id_{i}>''' for i in range(__snake_case	)]
       elif extra_ids > 0 and additional_special_tokens is not None:
          # Check that we have the right number of extra special tokens
          UpperCAmelCase_							:      Any						=   len(set(filter(lambda __snake_case	: bool('''extra_id_''' in str(__snake_case	)	)       ,   __snake_case	)	)	)
          if extra_tokens != extra_ids:
             raise ValueError(
                 f'''Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are'''
                 ''' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids'''
                 ''' tokens'''	)

       super().__init__(
           __snake_case       ,   tokenizer_file=__snake_case       ,   eos_token=__snake_case       ,   unk_token=__snake_case       ,   pad_token=__snake_case       ,   extra_ids=__snake_case       ,   additional_special_tokens=__snake_case       ,   **__snake_case       ,   )

       UpperCAmelCase_							:      str						=   vocab_file
       UpperCAmelCase_							:      List[str]						=   False if not self.vocab_file else True
       UpperCAmelCase_							:      Union[str, Any]						=   extra_ids





    @staticmethod
    def 					_lowerCamelCase (	__snake_case				:   Dict       ,   __snake_case				:   List[str]       ,   __snake_case				:   Tuple	):





       '''simple docstring'''
       if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
          UpperCAmelCase_							:      str						=   TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
          if init_max_model_length is not None and init_max_model_length != max_model_length:
             return init_max_model_length
          elif init_max_model_length is None:
             warnings.warn(
                 '''This tokenizer was incorrectly instantiated with a model max length of'''
                 f''' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this'''
                 ''' behavior is kept to avoid breaking backwards compatibility when padding/encoding with'''
                 ''' `truncation is True`.\n- Be aware that you SHOULD NOT rely on'''
                 f''' {pretrained_model_name_or_path} automatically truncating your input to'''
                 f''' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences'''
                 f''' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with'''
                 ''' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please'''
                 ''' instantiate this tokenizer with `model_max_length` set to your preferred value.'''       ,   __snake_case       ,   )

       return max_model_length





    def 					_lowerCamelCase (	self				:   Dict       ,   __snake_case				:   str       ,   __snake_case				:   Optional[str] = None	):





       '''simple docstring'''
       if not self.can_save_slow_tokenizer:
          raise ValueError(
              '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
              '''tokenizer.'''	)

       if not os.path.isdir(__snake_case	):
          logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''	)
          return
       UpperCAmelCase_							:      str						=   os.path.join(
           __snake_case       ,   (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']	)

       if os.path.abspath(self.vocab_file	) != os.path.abspath(__snake_case	):
          copyfile(self.vocab_file       ,   __snake_case	)
          logger.info(f'''Copy vocab file to {out_vocab_file}'''	)

       return (out_vocab_file,)





    def 					_lowerCamelCase (	self				:   List[str]       ,   __snake_case				:   List[int]       ,   __snake_case				:   Optional[List[int]] = None	):





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[Any]						=   token_ids_a + [self.eos_token_id]
       if token_ids_a is None:
          return self.prefix_tokens + token_ids_a
       else:
          UpperCAmelCase_							:      int						=   token_ids_a + [self.eos_token_id]
          return self.prefix_tokens + token_ids_a + token_ids_a





    def 					_lowerCamelCase (	self				:   Dict       ,   __snake_case				:   List[int]       ,   __snake_case				:   Optional[List[int]] = None	):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   [self.eos_token_id]

       if token_ids_a is None:
          return len(token_ids_a + eos	) * [0]
       return len(token_ids_a + eos + token_ids_a + eos	) * [0]





    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       return list(
           set(filter(lambda __snake_case	: bool(re.search(R'''<extra_id_\d+>'''       ,   __snake_case	)	) is not None       ,   self.additional_special_tokens	)	)	)





    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       return [self.convert_tokens_to_ids(__snake_case	) for token in self.get_sentinel_tokens()]