

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  (      SCREAMING_SNAKE_CASE    ,    unittest.TestCase							):
  _a		    =						BertGenerationTokenizer
  _a		    =						False
  _a		    =						True




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        super().setUp()

        _lowercase			 =BertGenerationTokenizer(lowerCAmelCase							,     keep_accents=lowerCAmelCase      )
        tokenizer.save_pretrained(self.tmpdirname      )




  def 						A__  (       self      )						->				Dict:
        '''simple docstring'''






        _lowercase			 ='<s>'
        _lowercase			 =1

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




  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =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(lowerCAmelCase      )							,     1_002      )




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        self.assertEqual(self.get_tokenizer().vocab_size							,     1_000      )




  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






        _lowercase			 =BertGenerationTokenizer(lowerCAmelCase							,     keep_accents=lowerCAmelCase      )

        _lowercase			 =tokenizer.tokenize('This is a test'      )
        self.assertListEqual(lowerCAmelCase							,     ['▁This', '▁is', '▁a', '▁t', 'est']      )

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

        _lowercase			 =tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
        self.assertListEqual(
            lowerCAmelCase							,     [
                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',
                'é',
                '.',
            ]							,     )
        _lowercase			 =tokenizer.convert_tokens_to_ids(lowerCAmelCase      )
        self.assertListEqual(
            lowerCAmelCase							,     [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]							,     )

        _lowercase			 =tokenizer.convert_ids_to_tokens(lowerCAmelCase      )
        self.assertListEqual(
            lowerCAmelCase							,     [
                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 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        return BertGenerationTokenizer.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'      )




  @slow
  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 ='Hello World!'
        _lowercase			 =[18_536, 2_260, 101]

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




  @slow
  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =(
            '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'
        )
        _lowercase			 =[
            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(lowerCAmelCase							,     self.big_tokenizer.encode(lowerCAmelCase      )      )




  @require_torch
  @slow
  def 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        import torch

        from transformers import BertGenerationConfig, BertGenerationEncoder

        # Build sequence
        _lowercase			 =list(self.big_tokenizer.get_vocab().keys()      )[:10]
        _lowercase			 =' '.join(lowerCAmelCase      )
        _lowercase			 =self.big_tokenizer.encode_plus(lowerCAmelCase							,     return_tensors='pt'							,     return_token_type_ids=lowerCAmelCase      )
        _lowercase			 =self.big_tokenizer.batch_encode_plus(
            [sequence + ' ' + sequence]							,     return_tensors='pt'							,     return_token_type_ids=lowerCAmelCase      )

        _lowercase			 =BertGenerationConfig()
        _lowercase			 =BertGenerationEncoder(lowerCAmelCase      )

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

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




  @slow
  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






        _lowercase			 ={'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=lowerCAmelCase							,     model_name='google/bert_for_seq_generation_L-24_bbc_encoder'							,     revision='c817d1fd1be2ffa69431227a1fe320544943d4db'							,     )





import os
def   a   (    )					->   Optional[int]:





      """simple docstring"""



      with open(os.path.dirname(A__  ) + '/grid.txt'  ) as f:
            _lowercase			 =[]  # noqa: E741
            for _ in range(20  ):
                  l.append([int(A__  ) for x in f.readline().split()]  )

            _lowercase			 =0

            # right
            for i in range(20  ):
                  for j in range(17  ):
                        _lowercase			 =l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
                        if temp > maximum:
                              _lowercase			 =temp

        # down
            for i in range(17  ):
                  for j in range(20  ):
                        _lowercase			 =l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
                        if temp > maximum:
                              _lowercase			 =temp

        # diagonal 1
            for i in range(17  ):
                  for j in range(17  ):
                        _lowercase			 =l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
                        if temp > maximum:
                              _lowercase			 =temp

        # diagonal 2
            for i in range(17  ):
                  for j in range(3   ,     20  ):
                        _lowercase			 =l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
                        if temp > maximum:
                              _lowercase			 =temp
            return maximum


if __name__ == "__main__":
  print(solution())


