import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import (
        MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
        TimesformerForVideoClassification,
        TimesformerModel,
    )
    from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from transformers import VideoMAEImageProcessor


class      lowerCamelCase_					:






    '''simple docstring'''






    def __init__(     self			,			__lowercase			,			__lowercase=13			,			__lowercase=10			,			__lowercase=3			,			__lowercase=2			,			__lowercase=2			,			__lowercase=True			,			__lowercase=True			,			__lowercase=32			,			__lowercase=5			,			__lowercase=4			,			__lowercase=37			,			__lowercase="gelu"			,			__lowercase=0.1			,			__lowercase=0.1			,			__lowercase=10			,			__lowercase=0.02			,			__lowercase="divided_space_time"			,			__lowercase=None			,			)	->     List[str]:
        __UpperCamelCase					:int        =		parent
        __UpperCamelCase					:List[Any]        =		batch_size
        __UpperCamelCase					:Union[str, Any]        =		image_size
        __UpperCamelCase					:int        =		num_channels
        __UpperCamelCase					:List[str]        =		patch_size
        __UpperCamelCase					:Tuple        =		num_frames
        __UpperCamelCase					:Optional[int]        =		is_training
        __UpperCamelCase					:List[str]        =		use_labels
        __UpperCamelCase					:Any        =		hidden_size
        __UpperCamelCase					:str        =		num_hidden_layers
        __UpperCamelCase					:int        =		num_attention_heads
        __UpperCamelCase					:Dict        =		intermediate_size
        __UpperCamelCase					:int        =		hidden_act
        __UpperCamelCase					:str        =		hidden_dropout_prob
        __UpperCamelCase					:Optional[Any]        =		attention_probs_dropout_prob
        __UpperCamelCase					:Optional[int]        =		attention_type
        __UpperCamelCase					:Tuple        =		initializer_range
        __UpperCamelCase					:int        =		scope
        __UpperCamelCase					:int        =		num_labels

        # in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
        __UpperCamelCase					:Any        =		(image_size // patch_size) ** 2
        __UpperCamelCase					:Union[str, Any]        =		(num_frames) * self.num_patches_per_frame + 1







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Dict        =		floats_tensor(
            [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

        __UpperCamelCase					:List[str]        =		None
        if self.use_labels:
            __UpperCamelCase					:Dict        =		ids_tensor([self.batch_size]			,			self.num_labels)

        __UpperCamelCase					:Tuple        =		self.get_config()

        return config, pixel_values, labels







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:str        =		TimesformerConfig(
            image_size=self.image_size			,			patch_size=self.patch_size			,			num_channels=self.num_channels			,			num_frames=self.num_frames			,			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			,			initializer_range=self.initializer_range			,			attention_type=self.attention_type			,			)
        __UpperCamelCase					:Optional[int]        =		self.num_labels
        return config







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase)	->     int:
        __UpperCamelCase					:Optional[int]        =		TimesformerModel(config=lowerCAmelCase_)
        model.to(lowerCAmelCase_)
        model.eval()
        __UpperCamelCase					:List[str]        =		model(lowerCAmelCase_)
        self.parent.assertEqual(result.last_hidden_state.shape			,			(self.batch_size, self.seq_length, self.hidden_size))







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase)	->     Tuple:
        __UpperCamelCase					:List[Any]        =		TimesformerForVideoClassification(lowerCAmelCase_)
        model.to(lowerCAmelCase_)
        model.eval()

        __UpperCamelCase					:Union[str, Any]        =		model(lowerCAmelCase_)

        # verify the logits shape
        __UpperCamelCase					:int        =		torch.Size((self.batch_size, self.num_labels))
        self.parent.assertEqual(result.logits.shape			,			lowerCAmelCase_)







    def       UpperCamelCase__       (     self)	->     Optional[int]:
        __UpperCamelCase					:List[Any]        =		self.prepare_config_and_inputs()
        __UpperCamelCase  ,	__UpperCamelCase  ,	__UpperCamelCase					:Dict        =		config_and_inputs
        __UpperCamelCase					:Any        =		{'''pixel_values''': pixel_values}
        return config, inputs_dict


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






    '''simple docstring'''






    a__     :						Any      =				(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
    a__     :						List[str]      =				(
        {'''feature-extraction''': TimesformerModel, '''video-classification''': TimesformerForVideoClassification}
        if is_torch_available()
        else {}
    )

    a__     :						Any      =				False
    a__     :						Dict      =				False
    a__     :						List[str]      =				False
    a__     :						Tuple      =				False







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:Union[str, Any]        =		TimesformerModelTester(self)
        __UpperCamelCase					:List[str]        =		ConfigTester(
            self			,			config_class=lowerCAmelCase_			,			has_text_modality=lowerCAmelCase_			,			hidden_size=37)







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase=False)	->     Optional[Any]:
        __UpperCamelCase					:Optional[int]        =		copy.deepcopy(lowerCAmelCase_)

        if return_labels:
            if model_class in get_values(lowerCAmelCase_):
                __UpperCamelCase					:Dict        =		torch.zeros(
                    self.model_tester.batch_size			,			dtype=torch.long			,			device=lowerCAmelCase_)

        return inputs_dict







    def       UpperCamelCase__       (     self)	->     Dict:
        self.config_tester.run_common_tests()







    @unittest.skip(reason='''TimeSformer does not use inputs_embeds''')
    def       UpperCamelCase__       (     self)	->     Tuple:
        pass







    def       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase  ,	__UpperCamelCase					:Any        =		self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            __UpperCamelCase					:str        =		model_class(lowerCAmelCase_)
            self.assertIsInstance(model.get_input_embeddings()			,			(nn.Module))
            __UpperCamelCase					:int        =		model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(lowerCAmelCase_			,			nn.Linear))







    def       UpperCamelCase__       (     self)	->     str:
        __UpperCamelCase  ,	__UpperCamelCase					:str        =		self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            __UpperCamelCase					:List[str]        =		model_class(lowerCAmelCase_)
            __UpperCamelCase					:Union[str, Any]        =		inspect.signature(model.forward)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            __UpperCamelCase					:Tuple        =		[*signature.parameters.keys()]

            __UpperCamelCase					:Optional[Any]        =		['''pixel_values''']
            self.assertListEqual(arg_names[:1]			,			lowerCAmelCase_)







    def       UpperCamelCase__       (     self)	->     List[Any]:
        __UpperCamelCase					:Tuple        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase_)







    def       UpperCamelCase__       (     self)	->     Tuple:
        __UpperCamelCase					:List[str]        =		self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase_)







    @slow
    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCamelCase					:Any        =		TimesformerModel.from_pretrained(lowerCAmelCase_)
            self.assertIsNotNone(lowerCAmelCase_)







    def       UpperCamelCase__       (     self)	->     Optional[int]:
        if not self.has_attentions:
            pass

        else:
            __UpperCamelCase  ,	__UpperCamelCase					:str        =		self.model_tester.prepare_config_and_inputs_for_common()
            __UpperCamelCase					:str        =		True

            for model_class in self.all_model_classes:
                __UpperCamelCase					:int        =		self.model_tester.seq_length
                __UpperCamelCase					:str        =		self.model_tester.num_frames

                __UpperCamelCase					:str        =		True
                __UpperCamelCase					:List[Any]        =		False
                __UpperCamelCase					:Optional[int]        =		True
                __UpperCamelCase					:List[str]        =		model_class(lowerCAmelCase_)
                model.to(lowerCAmelCase_)
                model.eval()
                with torch.no_grad():
                    __UpperCamelCase					:str        =		model(**self._prepare_for_class(lowerCAmelCase_			,			lowerCAmelCase_))
                __UpperCamelCase					:Any        =		outputs.attentions
                self.assertEqual(len(lowerCAmelCase_)			,			self.model_tester.num_hidden_layers)

                # check that output_attentions also work using config
                del inputs_dict["output_attentions"]
                __UpperCamelCase					:Union[str, Any]        =		True
                __UpperCamelCase					:Union[str, Any]        =		model_class(lowerCAmelCase_)
                model.to(lowerCAmelCase_)
                model.eval()
                with torch.no_grad():
                    __UpperCamelCase					:Tuple        =		model(**self._prepare_for_class(lowerCAmelCase_			,			lowerCAmelCase_))
                __UpperCamelCase					:Tuple        =		outputs.attentions
                self.assertEqual(len(lowerCAmelCase_)			,			self.model_tester.num_hidden_layers)

                # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
                self.assertListEqual(
                    list(attentions[0].shape[-3:])			,			[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]			,			)
                __UpperCamelCase					:Union[str, Any]        =		len(lowerCAmelCase_)

                # Check attention is always last and order is fine
                __UpperCamelCase					:Optional[int]        =		True
                __UpperCamelCase					:Tuple        =		True
                __UpperCamelCase					:Tuple        =		model_class(lowerCAmelCase_)
                model.to(lowerCAmelCase_)
                model.eval()
                with torch.no_grad():
                    __UpperCamelCase					:Tuple        =		model(**self._prepare_for_class(lowerCAmelCase_			,			lowerCAmelCase_))

                self.assertEqual(out_len + 1			,			len(lowerCAmelCase_))

                __UpperCamelCase					:Optional[int]        =		outputs.attentions

                self.assertEqual(len(lowerCAmelCase_)			,			self.model_tester.num_hidden_layers)

                # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
                self.assertListEqual(
                    list(self_attentions[0].shape[-3:])			,			[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]			,			)







    def       UpperCamelCase__       (     self)	->     List[Any]:
        def check_hidden_states_output(__lowercase			,			__lowercase			,			__lowercase):
            __UpperCamelCase					:Any        =		model_class(lowerCAmelCase_)
            model.to(lowerCAmelCase_)
            model.eval()

            with torch.no_grad():
                __UpperCamelCase					:Any        =		model(**self._prepare_for_class(lowerCAmelCase_			,			lowerCAmelCase_))

            __UpperCamelCase					:List[Any]        =		outputs.hidden_states
            __UpperCamelCase					:Optional[int]        =		self.model_tester.num_hidden_layers + 1
            self.assertEqual(len(lowerCAmelCase_)			,			lowerCAmelCase_)

            __UpperCamelCase					:List[Any]        =		self.model_tester.seq_length

            self.assertListEqual(
                list(hidden_states[0].shape[-2:])			,			[seq_length, self.model_tester.hidden_size]			,			)

        __UpperCamelCase  ,	__UpperCamelCase					:List[str]        =		self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            __UpperCamelCase					:List[str]        =		True
            check_hidden_states_output(lowerCAmelCase_			,			lowerCAmelCase_			,			lowerCAmelCase_)

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            __UpperCamelCase					:Tuple        =		True

            check_hidden_states_output(lowerCAmelCase_			,			lowerCAmelCase_			,			lowerCAmelCase_)



def lowerCamelCase  (       ):
    '''simple docstring'''







    __UpperCamelCase					:List[str]        =		hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''  ,      filename='''eating_spaghetti.npy'''  ,      repo_type='''dataset'''     )
    __UpperCamelCase					:List[str]        =		np.load(snake_case__     )
    return list(snake_case__     )


@require_torch
@require_vision
class      lowerCamelCase_					(       unittest.TestCase			):






    '''simple docstring'''






    @cached_property
    def       UpperCamelCase__       (     self)	->     List[str]:
        # logits were tested with a different mean and std, so we use the same here
        return (
            VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,			image_std=[0.5, 0.5, 0.5])
            if is_vision_available()
            else None
        )







    @slow
    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        __UpperCamelCase					:List[Any]        =		TimesformerForVideoClassification.from_pretrained('''facebook/timesformer-base-finetuned-k400''').to(
            lowerCAmelCase_)

        __UpperCamelCase					:Dict        =		self.default_image_processor
        __UpperCamelCase					:Union[str, Any]        =		prepare_video()
        __UpperCamelCase					:Optional[Any]        =		image_processor(video[:8]			,			return_tensors='''pt''').to(lowerCAmelCase_)

        # forward pass
        with torch.no_grad():
            __UpperCamelCase					:str        =		model(**lowerCAmelCase_)

        # verify the logits
        __UpperCamelCase					:int        =		torch.Size((1, 400))
        self.assertEqual(outputs.logits.shape			,			lowerCAmelCase_)

        __UpperCamelCase					:Any        =		torch.tensor([-0.30_16, -0.77_13, -0.42_05]).to(lowerCAmelCase_)

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



import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__lowercase										= '''▁'''

__lowercase										= get_tests_dir('''fixtures/test_sentencepiece.model''')


@require_sentencepiece
class      lowerCamelCase_					(       UpperCAmelCase_						,     unittest.TestCase			):






    '''simple docstring'''






    a__     :						int      =				BertGenerationTokenizer
    a__     :						Dict      =				False
    a__     :						str      =				True







    def       UpperCamelCase__       (     self)	->     List[str]:
        super().setUp()

        __UpperCamelCase					:Optional[Any]        =		BertGenerationTokenizer(__lowercase			,			keep_accents=__lowercase)
        tokenizer.save_pretrained(self.tmpdirname)







    def       UpperCamelCase__       (     self)	->     int:
        __UpperCamelCase					:Dict        =		'''<s>'''
        __UpperCamelCase					:Dict        =		1

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowercase)			,			__lowercase)
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowercase)			,			__lowercase)







    def       UpperCamelCase__       (     self)	->     Optional[int]:
        __UpperCamelCase					:Optional[Any]        =		list(self.get_tokenizer().get_vocab().keys())

        self.assertEqual(vocab_keys[0]			,			'''<unk>''')
        self.assertEqual(vocab_keys[1]			,			'''<s>''')
        self.assertEqual(vocab_keys[-1]			,			'''<pad>''')
        self.assertEqual(len(__lowercase)			,			1_002)







    def       UpperCamelCase__       (     self)	->     Dict:
        self.assertEqual(self.get_tokenizer().vocab_size			,			1_000)







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:str        =		BertGenerationTokenizer(__lowercase			,			keep_accents=__lowercase)

        __UpperCamelCase					:Optional[Any]        =		tokenizer.tokenize('''This is a test''')
        self.assertListEqual(__lowercase			,			['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''])

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(__lowercase)			,			[285, 46, 10, 170, 382]			,			)

        __UpperCamelCase					:List[Any]        =		tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
        self.assertListEqual(
            __lowercase			,			[
                SPIECE_UNDERLINE + '''I''',
                SPIECE_UNDERLINE + '''was''',
                SPIECE_UNDERLINE + '''b''',
                '''or''',
                '''n''',
                SPIECE_UNDERLINE + '''in''',
                SPIECE_UNDERLINE + '''''',
                '''9''',
                '''2''',
                '''0''',
                '''0''',
                '''0''',
                ''',''',
                SPIECE_UNDERLINE + '''and''',
                SPIECE_UNDERLINE + '''this''',
                SPIECE_UNDERLINE + '''is''',
                SPIECE_UNDERLINE + '''f''',
                '''al''',
                '''s''',
                '''é''',
                '''.''',
            ]			,			)
        __UpperCamelCase					:Any        =		tokenizer.convert_tokens_to_ids(__lowercase)
        self.assertListEqual(
            __lowercase			,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]			,			)

        __UpperCamelCase					:Tuple        =		tokenizer.convert_ids_to_tokens(__lowercase)
        self.assertListEqual(
            __lowercase			,			[
                SPIECE_UNDERLINE + '''I''',
                SPIECE_UNDERLINE + '''was''',
                SPIECE_UNDERLINE + '''b''',
                '''or''',
                '''n''',
                SPIECE_UNDERLINE + '''in''',
                SPIECE_UNDERLINE + '''''',
                '''<unk>''',
                '''2''',
                '''0''',
                '''0''',
                '''0''',
                ''',''',
                SPIECE_UNDERLINE + '''and''',
                SPIECE_UNDERLINE + '''this''',
                SPIECE_UNDERLINE + '''is''',
                SPIECE_UNDERLINE + '''f''',
                '''al''',
                '''s''',
                '''<unk>''',
                '''.''',
            ]			,			)







    @cached_property
    def       UpperCamelCase__       (     self)	->     int:
        return BertGenerationTokenizer.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder''')







    @slow
    def       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase					:Optional[Any]        =		'''Hello World!'''
        __UpperCamelCase					:Optional[int]        =		[18_536, 2_260, 101]

        self.assertListEqual(__lowercase			,			self.big_tokenizer.encode(__lowercase))







    @slow
    def       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase					:Optional[Any]        =		(
            '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
            ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
        )
        __UpperCamelCase					:Union[str, Any]        =		[
            871,
            419,
            358,
            946,
            991,
            2_521,
            452,
            358,
            1_357,
            387,
            7_751,
            3_536,
            112,
            985,
            456,
            126,
            865,
            938,
            5_400,
            5_734,
            458,
            1_368,
            467,
            786,
            2_462,
            5_246,
            1_159,
            633,
            865,
            4_519,
            457,
            582,
            852,
            2_557,
            427,
            916,
            508,
            405,
            34_324,
            497,
            391,
            408,
            11_342,
            1_244,
            385,
            100,
            938,
            985,
            456,
            574,
            362,
            12_597,
            3_200,
            3_129,
            1_172,
        ]

        self.assertListEqual(__lowercase			,			self.big_tokenizer.encode(__lowercase))







    @require_torch
    @slow
    def       UpperCamelCase__       (     self)	->     Optional[int]:
        import torch

        from transformers import BertGenerationConfig, BertGenerationEncoder

        # Build sequence
        __UpperCamelCase					:Optional[Any]        =		list(self.big_tokenizer.get_vocab().keys())[:10]
        __UpperCamelCase					:Optional[int]        =		''' '''.join(__lowercase)
        __UpperCamelCase					:Optional[int]        =		self.big_tokenizer.encode_plus(__lowercase			,			return_tensors='''pt'''			,			return_token_type_ids=__lowercase)
        __UpperCamelCase					:List[str]        =		self.big_tokenizer.batch_encode_plus(
            [sequence + ''' ''' + sequence]			,			return_tensors='''pt'''			,			return_token_type_ids=__lowercase)

        __UpperCamelCase					:List[Any]        =		BertGenerationConfig()
        __UpperCamelCase					:Optional[Any]        =		BertGenerationEncoder(__lowercase)

        assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

        with torch.no_grad():
            model(**__lowercase)
            model(**__lowercase)







    @slow
    def       UpperCamelCase__       (     self)	->     Dict:
        # fmt: off
        __UpperCamelCase					:List[str]        =		{'''input_ids''': [[39_286, 458, 36_335, 2_001, 456, 13_073, 13_266, 455, 113, 7_746, 1_741, 11_157, 391, 13_073, 13_266, 455, 113, 3_967, 35_412, 113, 4_936, 109, 3_870, 2_377, 113, 30_084, 45_720, 458, 134, 17_496, 112, 503, 11_672, 113, 118, 112, 5_665, 13_347, 38_687, 112, 1_496, 31_389, 112, 3_268, 47_264, 134, 962, 112, 16_377, 8_035, 23_130, 430, 12_169, 15_518, 28_592, 458, 146, 41_697, 109, 391, 12_169, 15_518, 16_689, 458, 146, 41_358, 109, 452, 726, 4_034, 111, 763, 35_412, 5_082, 388, 1_903, 111, 9_051, 391, 2_870, 48_918, 1_900, 1_123, 550, 998, 112, 9_586, 15_985, 455, 391, 410, 22_955, 37_636, 114], [448, 17_496, 419, 3_663, 385, 763, 113, 27_533, 2_870, 3_283, 13_043, 1_639, 24_713, 523, 656, 24_013, 18_550, 2_521, 517, 27_014, 21_244, 420, 1_212, 1_465, 391, 927, 4_833, 388, 578, 11_786, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [484, 2_169, 7_687, 21_932, 18_146, 726, 363, 17_032, 3_391, 114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__lowercase			,			model_name='''google/bert_for_seq_generation_L-24_bbc_encoder'''			,			revision='''c817d1fd1be2ffa69431227a1fe320544943d4db'''			,			)





