
import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import DetaImageProcessor




class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase=7		,						lowerCamelCase=3		,						lowerCamelCase=30		,						lowerCamelCase=4_00		,						lowerCamelCase=True		,						lowerCamelCase=None		,						lowerCamelCase=True		,						lowerCamelCase=[0.5, 0.5, 0.5]		,						lowerCamelCase=[0.5, 0.5, 0.5]		,						lowerCamelCase=True		,						lowerCamelCase=1 / 2_55		,						lowerCamelCase=True		,						):
          # by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
          snake_case__    =					size if size is not None else {"shortest_edge": 18, "longest_edge": 13_33}
          snake_case__    =					parent
          snake_case__    =					batch_size
          snake_case__    =					num_channels
          snake_case__    =					min_resolution
          snake_case__    =					max_resolution
          snake_case__    =					do_resize
          snake_case__    =					size
          snake_case__    =					do_normalize
          snake_case__    =					image_mean
          snake_case__    =					image_std
          snake_case__    =					do_rescale
          snake_case__    =					rescale_factor
          snake_case__    =					do_pad
      def A_      (      self			):
          return {
              "do_resize": self.do_resize,
              "size": self.size,
              "do_normalize": self.do_normalize,
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_rescale": self.do_rescale,
              "rescale_factor": self.rescale_factor,
              "do_pad": self.do_pad,
          }



      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase=False			):
          if not batched:
              snake_case__    =					image_inputs[0]
              if isinstance(lowerCamelCase		,						Image.Image			):
                  snake_case__    ,       snake_case__    =					image.size
              else:
                  snake_case__    ,       snake_case__    =					image.shape[1], image.shape[2]
              if w < h:
                  snake_case__    =					int(self.size["shortest_edge"] * h / w			)
                  snake_case__    =					self.size["shortest_edge"]
              elif w > h:
                  snake_case__    =					self.size["shortest_edge"]
                  snake_case__    =					int(self.size["shortest_edge"] * w / h			)
              else:
                  snake_case__    =					self.size["shortest_edge"]
                  snake_case__    =					self.size["shortest_edge"]

          else:
              snake_case__    =					[]
              for image in image_inputs:
                  snake_case__    ,       snake_case__    =					self.get_expected_values([image]			)
                  expected_values.append((expected_height, expected_width)			)
              snake_case__    =					max(lowerCamelCase		,						key=lambda lowerCamelCase			: item[0]			)[0]
              snake_case__    =					max(lowerCamelCase		,						key=lambda lowerCamelCase			: item[1]			)[1]

          return expected_height, expected_width





@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       unittest.TestCase			):
      _A    :		List[str]     						=  DetaImageProcessor if is_vision_available() else None
      def A_      (      self			):
          snake_case__    =					DetaImageProcessingTester(self			)
      @property
      def A_      (      self			):
          return self.image_processor_tester.prepare_image_processor_dict()
      def A_      (      self			):
          snake_case__    =					self.image_processing_class(**self.image_processor_dict			)
          self.assertTrue(hasattr(lowerCamelCase		,						"image_mean"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"image_std"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"do_normalize"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"do_resize"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"do_rescale"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"do_pad"			)			)
          self.assertTrue(hasattr(lowerCamelCase		,						"size"			)			)
      def A_      (      self			):
          snake_case__    =					self.image_processing_class.from_dict(self.image_processor_dict			)
          self.assertEqual(image_processor.size		,						{"shortest_edge": 18, "longest_edge": 13_33}			)
          self.assertEqual(image_processor.do_pad		,						lowerCamelCase			)
      def A_      (      self			):
          pass
      def A_      (      self			):
          # Initialize image_processing
          snake_case__    =					self.image_processing_class(**self.image_processor_dict			)
          # create random PIL images
          snake_case__    =					prepare_image_inputs(self.image_processor_tester		,						equal_resolution=lowerCamelCase			)
          for image in image_inputs:
              self.assertIsInstance(lowerCamelCase		,						Image.Image			)

          # Test not batched input
          snake_case__    =					image_processing(image_inputs[0]		,						return_tensors="pt"			).pixel_values

          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase			)

          self.assertEqual(
              encoded_images.shape		,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,						)

          # Test batched
          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase		,						batched=lowerCamelCase			)

          snake_case__    =					image_processing(lowerCamelCase		,						return_tensors="pt"			).pixel_values
          self.assertEqual(
              encoded_images.shape		,						(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		,						)
      def A_      (      self			):
          # Initialize image_processing
          snake_case__    =					self.image_processing_class(**self.image_processor_dict			)
          # create random numpy tensors
          snake_case__    =					prepare_image_inputs(self.image_processor_tester		,						equal_resolution=lowerCamelCase		,						numpify=lowerCamelCase			)
          for image in image_inputs:
              self.assertIsInstance(lowerCamelCase		,						np.ndarray			)

          # Test not batched input
          snake_case__    =					image_processing(image_inputs[0]		,						return_tensors="pt"			).pixel_values

          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase			)

          self.assertEqual(
              encoded_images.shape		,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,						)

          # Test batched
          snake_case__    =					image_processing(lowerCamelCase		,						return_tensors="pt"			).pixel_values

          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase		,						batched=lowerCamelCase			)

          self.assertEqual(
              encoded_images.shape		,						(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		,						)
      def A_      (      self			):
          # Initialize image_processing
          snake_case__    =					self.image_processing_class(**self.image_processor_dict			)
          # create random PyTorch tensors
          snake_case__    =					prepare_image_inputs(self.image_processor_tester		,						equal_resolution=lowerCamelCase		,						torchify=lowerCamelCase			)
          for image in image_inputs:
              self.assertIsInstance(lowerCamelCase		,						torch.Tensor			)

          # Test not batched input
          snake_case__    =					image_processing(image_inputs[0]		,						return_tensors="pt"			).pixel_values

          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase			)

          self.assertEqual(
              encoded_images.shape		,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,						)

          # Test batched
          snake_case__    =					image_processing(lowerCamelCase		,						return_tensors="pt"			).pixel_values

          snake_case__    ,       snake_case__    =					self.image_processor_tester.get_expected_values(lowerCamelCase		,						batched=lowerCamelCase			)

          self.assertEqual(
              encoded_images.shape		,						(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  expected_height,
                  expected_width,
              )		,						)
      @slow
      def A_      (      self			):
          # prepare image and target
          snake_case__    =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
          with open("./tests/fixtures/tests_samples/COCO/coco_annotations.txt"		,						"r"			) as f:
              snake_case__    =					json.loads(f.read()			)

          snake_case__    =					{"image_id": 3_97_69, "annotations": target}

          # encode them
          snake_case__    =					DetaImageProcessor()
          snake_case__    =					image_processing(images=lowerCamelCase		,						annotations=lowerCamelCase		,						return_tensors="pt"			)

          # verify pixel values
          snake_case__    =					torch.Size([1, 3, 8_00, 10_66]			)
          self.assertEqual(encoding["pixel_values"].shape		,						lowerCamelCase			)

          snake_case__    =					torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]			)
          self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)

          # verify area
          snake_case__    =					torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["area"]		,						lowerCamelCase			)			)
          # verify boxes
          snake_case__    =					torch.Size([6, 4]			)
          self.assertEqual(encoding["labels"][0]["boxes"].shape		,						lowerCamelCase			)
          snake_case__    =					torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]		,						lowerCamelCase		,						atol=1e-3			)			)
          # verify image_id
          snake_case__    =					torch.tensor([3_97_69]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]		,						lowerCamelCase			)			)
          # verify is_crowd
          snake_case__    =					torch.tensor([0, 0, 0, 0, 0, 0]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]		,						lowerCamelCase			)			)
          # verify class_labels
          snake_case__    =					torch.tensor([75, 75, 63, 65, 17, 17]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]		,						lowerCamelCase			)			)
          # verify orig_size
          snake_case__    =					torch.tensor([4_80, 6_40]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]		,						lowerCamelCase			)			)
          # verify size
          snake_case__    =					torch.tensor([8_00, 10_66]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["size"]		,						lowerCamelCase			)			)



      @slow
      def A_      (      self			):
          # prepare image, target and masks_path
          snake_case__    =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
          with open("./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt"		,						"r"			) as f:
              snake_case__    =					json.loads(f.read()			)

          snake_case__    =					{"file_name": "000000039769.png", "image_id": 3_97_69, "segments_info": target}

          snake_case__    =					pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic"			)

          # encode them
          snake_case__    =					DetaImageProcessor(format="coco_panoptic"			)
          snake_case__    =					image_processing(images=lowerCamelCase		,						annotations=lowerCamelCase		,						masks_path=lowerCamelCase		,						return_tensors="pt"			)

          # verify pixel values
          snake_case__    =					torch.Size([1, 3, 8_00, 10_66]			)
          self.assertEqual(encoding["pixel_values"].shape		,						lowerCamelCase			)

          snake_case__    =					torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]			)
          self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)

          # verify area
          snake_case__    =					torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["area"]		,						lowerCamelCase			)			)
          # verify boxes
          snake_case__    =					torch.Size([6, 4]			)
          self.assertEqual(encoding["labels"][0]["boxes"].shape		,						lowerCamelCase			)
          snake_case__    =					torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]		,						lowerCamelCase		,						atol=1e-3			)			)
          # verify image_id
          snake_case__    =					torch.tensor([3_97_69]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]		,						lowerCamelCase			)			)
          # verify is_crowd
          snake_case__    =					torch.tensor([0, 0, 0, 0, 0, 0]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]		,						lowerCamelCase			)			)
          # verify class_labels
          snake_case__    =					torch.tensor([17, 17, 63, 75, 75, 93]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]		,						lowerCamelCase			)			)
          # verify masks
          snake_case__    =					82_28_73
          self.assertEqual(encoding["labels"][0]["masks"].sum().item()		,						lowerCamelCase			)
          # verify orig_size
          snake_case__    =					torch.tensor([4_80, 6_40]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]		,						lowerCamelCase			)			)
          # verify size
          snake_case__    =					torch.tensor([8_00, 10_66]			)
          self.assertTrue(torch.allclose(encoding["labels"][0]["size"]		,						lowerCamelCase			)			)





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


__magic_name__  							=	'''▁'''

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




@require_sentencepiece
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       unittest.TestCase			):
      _A    :		List[str]     						=  BertGenerationTokenizer
      _A    :		int     						=  False
      _A    :		Optional[Any]     						=  True
      def A_      (      self			):
          super().setUp()

          snake_case__    =					BertGenerationTokenizer(lowerCamelCase		,						keep_accents=lowerCamelCase			)
          tokenizer.save_pretrained(self.tmpdirname			)
      def A_      (      self			):
          snake_case__    =					"<s>"
          snake_case__    =					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			):
          snake_case__    =					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			)		,						10_02			)
      def A_      (      self			):
          self.assertEqual(self.get_tokenizer().vocab_size		,						10_00			)
      def A_      (      self			):
          snake_case__    =					BertGenerationTokenizer(lowerCamelCase		,						keep_accents=lowerCamelCase			)

          snake_case__    =					tokenizer.tokenize("This is a test"			)
          self.assertListEqual(lowerCamelCase		,						["▁This", "▁is", "▁a", "▁t", "est"]			)

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowerCamelCase			)		,						[2_85, 46, 10, 1_70, 3_82]		,						)

          snake_case__    =					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",
                  "é",
                  ".",
              ]		,						)
          snake_case__    =					tokenizer.convert_tokens_to_ids(lowerCamelCase			)
          self.assertListEqual(
              lowerCamelCase		,						[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]		,						)

          snake_case__    =					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			):
          return BertGenerationTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"			)
      @slow
      def A_      (      self			):
          snake_case__    =					"Hello World!"
          snake_case__    =					[1_85_36, 22_60, 1_01]

          self.assertListEqual(lowerCamelCase		,						self.big_tokenizer.encode(lowerCamelCase			)			)
      @slow
      def A_      (      self			):
          snake_case__    =					(
              "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"
          )
          snake_case__    =					[
              8_71,
              4_19,
              3_58,
              9_46,
              9_91,
              25_21,
              4_52,
              3_58,
              13_57,
              3_87,
              77_51,
              35_36,
              1_12,
              9_85,
              4_56,
              1_26,
              8_65,
              9_38,
              54_00,
              57_34,
              4_58,
              13_68,
              4_67,
              7_86,
              24_62,
              52_46,
              11_59,
              6_33,
              8_65,
              45_19,
              4_57,
              5_82,
              8_52,
              25_57,
              4_27,
              9_16,
              5_08,
              4_05,
              3_43_24,
              4_97,
              3_91,
              4_08,
              1_13_42,
              12_44,
              3_85,
              1_00,
              9_38,
              9_85,
              4_56,
              5_74,
              3_62,
              1_25_97,
              32_00,
              31_29,
              11_72,
          ]

          self.assertListEqual(lowerCamelCase		,						self.big_tokenizer.encode(lowerCamelCase			)			)
      @require_torch
      @slow
      def A_      (      self			):
          import torch

          from transformers import BertGenerationConfig, BertGenerationEncoder

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

          snake_case__    =					BertGenerationConfig()
          snake_case__    =					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			):
          # fmt: off
          snake_case__    =					{"input_ids": [[3_92_86, 4_58, 3_63_35, 20_01, 4_56, 1_30_73, 1_32_66, 4_55, 1_13, 77_46, 17_41, 1_11_57, 3_91, 1_30_73, 1_32_66, 4_55, 1_13, 39_67, 3_54_12, 1_13, 49_36, 1_09, 38_70, 23_77, 1_13, 3_00_84, 4_57_20, 4_58, 1_34, 1_74_96, 1_12, 5_03, 1_16_72, 1_13, 1_18, 1_12, 56_65, 1_33_47, 3_86_87, 1_12, 14_96, 3_13_89, 1_12, 32_68, 4_72_64, 1_34, 9_62, 1_12, 1_63_77, 80_35, 2_31_30, 4_30, 1_21_69, 1_55_18, 2_85_92, 4_58, 1_46, 4_16_97, 1_09, 3_91, 1_21_69, 1_55_18, 1_66_89, 4_58, 1_46, 4_13_58, 1_09, 4_52, 7_26, 40_34, 1_11, 7_63, 3_54_12, 50_82, 3_88, 19_03, 1_11, 90_51, 3_91, 28_70, 4_89_18, 19_00, 11_23, 5_50, 9_98, 1_12, 95_86, 1_59_85, 4_55, 3_91, 4_10, 2_29_55, 3_76_36, 1_14], [4_48, 1_74_96, 4_19, 36_63, 3_85, 7_63, 1_13, 2_75_33, 28_70, 32_83, 1_30_43, 16_39, 2_47_13, 5_23, 6_56, 2_40_13, 1_85_50, 25_21, 5_17, 2_70_14, 2_12_44, 4_20, 12_12, 14_65, 3_91, 9_27, 48_33, 3_88, 5_78, 1_17_86, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4_84, 21_69, 76_87, 2_19_32, 1_81_46, 7_26, 3_63, 1_70_32, 33_91, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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"		,						)



