
import inspect
import unittest

from transformers import MobileNetVaConfig
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 transformers import MobileNetVaForImageClassification, MobileNetVaModel
  from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import MobileNetVaImageProcessor





class       __A(				UpperCAmelCase       ):

     def    lowercase__      (	self					:     List[Any]   ):
            lowerCamelCase_							  =					self.config_class(**self.inputs_dict   )
            self.parent.assertTrue(hasattr(__UpperCamelCase   ,					"""tf_padding"""   )   )
            self.parent.assertTrue(hasattr(__UpperCamelCase   ,					"""depth_multiplier"""   )   )





class       __A:

     def __init__(	self					:     str   ,					__UpperCamelCase					:     Union[str, Any]   ,					__UpperCamelCase					:     int=1_3   ,					__UpperCamelCase					:     Dict=3   ,					__UpperCamelCase					:     int=3_2   ,					__UpperCamelCase					:     Any=0.25   ,					__UpperCamelCase					:     Tuple=8   ,					__UpperCamelCase					:     int=True   ,					__UpperCamelCase					:     str=1_0_2_4   ,					__UpperCamelCase					:     List[Any]=3_2   ,					__UpperCamelCase					:     Union[str, Any]="relu6"   ,					__UpperCamelCase					:     Optional[Any]=0.1   ,					__UpperCamelCase					:     int=0.02   ,					__UpperCamelCase					:     List[Any]=True   ,					__UpperCamelCase					:     Any=True   ,					__UpperCamelCase					:     List[Any]=1_0   ,					__UpperCamelCase					:     List[Any]=None   ,					):
            lowerCamelCase_							  =					parent
            lowerCamelCase_							  =					batch_size
            lowerCamelCase_							  =					num_channels
            lowerCamelCase_							  =					image_size
            lowerCamelCase_							  =					depth_multiplier
            lowerCamelCase_							  =					min_depth
            lowerCamelCase_							  =					tf_padding
            lowerCamelCase_							  =					int(last_hidden_size * depth_multiplier   )
            lowerCamelCase_							  =					output_stride
            lowerCamelCase_							  =					hidden_act
            lowerCamelCase_							  =					classifier_dropout_prob
            lowerCamelCase_							  =					use_labels
            lowerCamelCase_							  =					is_training
            lowerCamelCase_							  =					num_labels
            lowerCamelCase_							  =					initializer_range
            lowerCamelCase_							  =					scope

     def    lowercase__      (	self					:     Tuple   ):
            lowerCamelCase_							  =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

            lowerCamelCase_							  =					None
            lowerCamelCase_							  =					None
            if self.use_labels:
                   lowerCamelCase_							  =					ids_tensor([self.batch_size]   ,					self.num_labels   )
                   lowerCamelCase_							  =					ids_tensor([self.batch_size, self.image_size, self.image_size]   ,					self.num_labels   )

            lowerCamelCase_							  =					self.get_config()

            return config, pixel_values, labels, pixel_labels

     def    lowercase__      (	self					:     int   ):
            return MobileNetVaConfig(
                num_channels=self.num_channels   ,					image_size=self.image_size   ,					depth_multiplier=self.depth_multiplier   ,					min_depth=self.min_depth   ,					tf_padding=self.tf_padding   ,					hidden_act=self.hidden_act   ,					classifier_dropout_prob=self.classifier_dropout_prob   ,					initializer_range=self.initializer_range   ,					)

     def    lowercase__      (	self					:     int   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     List[Any]   ,					__UpperCamelCase					:     List[str]   ,					__UpperCamelCase					:     int   ):
            lowerCamelCase_							  =					MobileNetVaModel(config=__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()
            lowerCamelCase_							  =					model(__UpperCamelCase   )
            self.parent.assertEqual(
                result.last_hidden_state.shape   ,					(
                    self.batch_size,
                    self.last_hidden_size,
                    self.image_size // self.output_stride,
                    self.image_size // self.output_stride,
                )   ,					)

     def    lowercase__      (	self					:     List[str]   ,					__UpperCamelCase					:     List[Any]   ,					__UpperCamelCase					:     Optional[Any]   ,					__UpperCamelCase					:     Optional[Any]   ,					__UpperCamelCase					:     int   ):
            lowerCamelCase_							  =					self.num_labels
            lowerCamelCase_							  =					MobileNetVaForImageClassification(__UpperCamelCase   )
            model.to(__UpperCamelCase   )
            model.eval()
            lowerCamelCase_							  =					model(__UpperCamelCase   ,					labels=__UpperCamelCase   )
            self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.num_labels)   )



     def    lowercase__      (	self					:     List[str]   ):
            lowerCamelCase_							  =					self.prepare_config_and_inputs()
            lowerCamelCase_  ,   lowerCamelCase_  ,   lowerCamelCase_  ,   lowerCamelCase_							  =					config_and_inputs
            lowerCamelCase_							  =					{"""pixel_values""": pixel_values}
            return config, inputs_dict





@require_torch
class       __A(				UpperCAmelCase     ,		UpperCAmelCase     ,		unittest.TestCase       ):
     SCREAMING_SNAKE_CASE			    =    (MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE			    =    (
         {'''feature-extraction''': MobileNetVaModel, '''image-classification''': MobileNetVaForImageClassification}
         if is_torch_available()
         else {}
     )

     SCREAMING_SNAKE_CASE			    =    False
     SCREAMING_SNAKE_CASE			    =    False
     SCREAMING_SNAKE_CASE			    =    False
     SCREAMING_SNAKE_CASE			    =    False

     def    lowercase__      (	self					:     Dict   ):
            lowerCamelCase_							  =					MobileNetVaModelTester(self   )
            lowerCamelCase_							  =					MobileNetVaConfigTester(self   ,					config_class=__UpperCamelCase   ,					has_text_modality=__UpperCamelCase   )

     def    lowercase__      (	self					:     Optional[int]   ):
            self.config_tester.run_common_tests()

     @unittest.skip(reason="""MobileNetV1 does not use inputs_embeds"""   )
     def    lowercase__      (	self					:     Optional[Any]   ):
            pass

     @unittest.skip(reason="""MobileNetV1 does not support input and output embeddings"""   )
     def    lowercase__      (	self					:     Union[str, Any]   ):
            pass

     @unittest.skip(reason="""MobileNetV1 does not output attentions"""   )
     def    lowercase__      (	self					:     int   ):
            pass

     def    lowercase__      (	self					:     Any   ):
            lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   lowerCamelCase_							  =					model_class(__UpperCamelCase   )
                   lowerCamelCase_							  =					inspect.signature(model.forward   )
                   # signature.parameters is an OrderedDict => so arg_names order is deterministic
                   lowerCamelCase_							  =					[*signature.parameters.keys()]

                   lowerCamelCase_							  =					["""pixel_values"""]
                   self.assertListEqual(arg_names[:1]   ,					__UpperCamelCase   )

     def    lowercase__      (	self					:     Optional[int]   ):
            lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__UpperCamelCase   )

     def    lowercase__      (	self					:     List[Any]   ):
            def check_hidden_states_output(__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Dict   ,					__UpperCamelCase					:     int   ):
                   lowerCamelCase_							  =					model_class(__UpperCamelCase   )
                   model.to(__UpperCamelCase   )
                   model.eval()

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

                   lowerCamelCase_							  =					outputs.hidden_states

                   lowerCamelCase_							  =					2_6
                   self.assertEqual(len(__UpperCamelCase   )   ,					__UpperCamelCase   )

            lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   lowerCamelCase_							  =					True
                   check_hidden_states_output(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   lowerCamelCase_							  =					True

                   check_hidden_states_output(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   )

     def    lowercase__      (	self					:     str   ):
            lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase   )



     @slow
     def    lowercase__      (	self					:     Union[str, Any]   ):
            for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   lowerCamelCase_							  =					MobileNetVaModel.from_pretrained(__UpperCamelCase   )
                   self.assertIsNotNone(__UpperCamelCase   )



def      __lowerCAmelCase						(							)  ->    str:
       lowerCamelCase_							  =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
       return image





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

     @cached_property
     def    lowercase__      (	self					:     Union[str, Any]   ):
            return (
                MobileNetVaImageProcessor.from_pretrained("""google/mobilenet_v1_1.0_224"""   ) if is_vision_available() else None
            )



     @slow
     def    lowercase__      (	self					:     Optional[int]   ):
            lowerCamelCase_							  =					MobileNetVaForImageClassification.from_pretrained("""google/mobilenet_v1_1.0_224"""   ).to(__UpperCamelCase   )

            lowerCamelCase_							  =					self.default_image_processor
            lowerCamelCase_							  =					prepare_img()
            lowerCamelCase_							  =					image_processor(images=__UpperCamelCase   ,					return_tensors="""pt"""   ).to(__UpperCamelCase   )

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

            # verify the logits
            lowerCamelCase_							  =					torch.Size((1, 1_0_0_1)   )
            self.assertEqual(outputs.logits.shape   ,					__UpperCamelCase   )

            lowerCamelCase_							  =					torch.tensor([-4.1739, -1.1233, 3.1205]   ).to(__UpperCamelCase   )

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







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
		from PIL import Image

		from transformers import OwlViTImageProcessor, OwlViTProcessor





@require_vision
class       __A(				unittest.TestCase       ):

					def    lowercase__      (	self					:     Union[str, Any]   ):
												lowerCamelCase_							  =					tempfile.mkdtemp()

												# fmt: off
												lowerCamelCase_							  =					["""""", """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
												# fmt: on
												lowerCamelCase_							  =					dict(zip(__UpperCamelCase   ,					range(len(__UpperCamelCase   )   )   )   )
												lowerCamelCase_							  =					["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
												lowerCamelCase_							  =					{"""unk_token""": """<unk>"""}

												lowerCamelCase_							  =					os.path.join(self.tmpdirname   ,					VOCAB_FILES_NAMES["""vocab_file"""]   )
												lowerCamelCase_							  =					os.path.join(self.tmpdirname   ,					VOCAB_FILES_NAMES["""merges_file"""]   )
												with open(self.vocab_file   ,					"""w"""   ,					encoding="""utf-8"""   ) as fp:
																			fp.write(json.dumps(__UpperCamelCase   ) + """\n"""   )
												with open(self.merges_file   ,					"""w"""   ,					encoding="""utf-8"""   ) as fp:
																			fp.write("""\n""".join(__UpperCamelCase   )   )

												lowerCamelCase_							  =					{
												    """do_resize""": True,
												    """size""": 2_0,
												    """do_center_crop""": True,
												    """crop_size""": 1_8,
												    """do_normalize""": True,
												    """image_mean""": [0.48145466, 0.4578275, 0.40821073],
												    """image_std""": [0.26862954, 0.26130258, 0.27577711],
												}
												lowerCamelCase_							  =					os.path.join(self.tmpdirname   ,					__UpperCamelCase   )
												with open(self.image_processor_file   ,					"""w"""   ,					encoding="""utf-8"""   ) as fp:
																			json.dump(__UpperCamelCase   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     str   ,					**__UpperCamelCase					:     Optional[Any]   ):
												return CLIPTokenizer.from_pretrained(self.tmpdirname   ,					pad_token="""!"""   ,					**__UpperCamelCase   )

					def    lowercase__      (	self					:     Any   ,					**__UpperCamelCase					:     List[Any]   ):
												return CLIPTokenizerFast.from_pretrained(self.tmpdirname   ,					pad_token="""!"""   ,					**__UpperCamelCase   )

					def    lowercase__      (	self					:     List[Any]   ,					**__UpperCamelCase					:     Optional[int]   ):
												return OwlViTImageProcessor.from_pretrained(self.tmpdirname   ,					**__UpperCamelCase   )

					def    lowercase__      (	self					:     Union[str, Any]   ):
												shutil.rmtree(self.tmpdirname   )

					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_							  =					[np.random.randint(2_5_5   ,					size=(3, 3_0, 4_0_0)   ,					dtype=np.uinta   )]

												lowerCamelCase_							  =					[Image.fromarray(np.moveaxis(__UpperCamelCase   ,					0   ,					-1   )   ) for x in image_inputs]

												return image_inputs

					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_							  =					self.get_tokenizer()
												lowerCamelCase_							  =					self.get_rust_tokenizer()
												lowerCamelCase_							  =					self.get_image_processor()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )
												processor_slow.save_pretrained(self.tmpdirname   )
												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(self.tmpdirname   ,					use_fast=__UpperCamelCase   )

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )
												processor_fast.save_pretrained(self.tmpdirname   )
												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(self.tmpdirname   )

												self.assertEqual(processor_slow.tokenizer.get_vocab()   ,					tokenizer_slow.get_vocab()   )
												self.assertEqual(processor_fast.tokenizer.get_vocab()   ,					tokenizer_fast.get_vocab()   )
												self.assertEqual(tokenizer_slow.get_vocab()   ,					tokenizer_fast.get_vocab()   )
												self.assertIsInstance(processor_slow.tokenizer   ,					__UpperCamelCase   )
												self.assertIsInstance(processor_fast.tokenizer   ,					__UpperCamelCase   )

												self.assertEqual(processor_slow.image_processor.to_json_string()   ,					image_processor.to_json_string()   )
												self.assertEqual(processor_fast.image_processor.to_json_string()   ,					image_processor.to_json_string()   )
												self.assertIsInstance(processor_slow.image_processor   ,					__UpperCamelCase   )
												self.assertIsInstance(processor_fast.image_processor   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=self.get_tokenizer()   ,					image_processor=self.get_image_processor()   )
												processor.save_pretrained(self.tmpdirname   )

												lowerCamelCase_							  =					self.get_tokenizer(bos_token="""(BOS)"""   ,					eos_token="""(EOS)"""   )
												lowerCamelCase_							  =					self.get_image_processor(do_normalize=__UpperCamelCase   )

												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(
												    self.tmpdirname   ,					bos_token="""(BOS)"""   ,					eos_token="""(EOS)"""   ,					do_normalize=__UpperCamelCase   )

												self.assertEqual(processor.tokenizer.get_vocab()   ,					tokenizer_add_kwargs.get_vocab()   )
												self.assertIsInstance(processor.tokenizer   ,					__UpperCamelCase   )

												self.assertEqual(processor.image_processor.to_json_string()   ,					image_processor_add_kwargs.to_json_string()   )
												self.assertIsInstance(processor.image_processor   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     Any   ):
												lowerCamelCase_							  =					self.get_image_processor()
												lowerCamelCase_							  =					self.get_tokenizer()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )

												lowerCamelCase_							  =					self.prepare_image_inputs()

												lowerCamelCase_							  =					image_processor(__UpperCamelCase   ,					return_tensors="""np"""   )
												lowerCamelCase_							  =					processor(images=__UpperCamelCase   ,					return_tensors="""np"""   )

												for key in input_image_proc.keys():
																			self.assertAlmostEqual(input_image_proc[key].sum()   ,					input_processor[key].sum()   ,					delta=1E-2   )

					def    lowercase__      (	self					:     Union[str, Any]   ):
												lowerCamelCase_							  =					self.get_image_processor()
												lowerCamelCase_							  =					self.get_tokenizer()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )

												lowerCamelCase_							  =					"""lower newer"""

												lowerCamelCase_							  =					processor(text=__UpperCamelCase   ,					return_tensors="""np"""   )

												lowerCamelCase_							  =					tokenizer(__UpperCamelCase   ,					return_tensors="""np"""   )

												for key in encoded_tok.keys():
																			self.assertListEqual(encoded_tok[key][0].tolist()   ,					encoded_processor[key][0].tolist()   )

					def    lowercase__      (	self					:     List[str]   ):
												lowerCamelCase_							  =					self.get_image_processor()
												lowerCamelCase_							  =					self.get_tokenizer()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )

												lowerCamelCase_							  =					"""lower newer"""
												lowerCamelCase_							  =					self.prepare_image_inputs()

												lowerCamelCase_							  =					processor(text=__UpperCamelCase   ,					images=__UpperCamelCase   )

												self.assertListEqual(list(inputs.keys()   )   ,					["""input_ids""", """attention_mask""", """pixel_values"""]   )

												# test if it raises when no input is passed
												with pytest.raises(__UpperCamelCase   ):
																			processor()

					def    lowercase__      (	self					:     List[Any]   ):
												lowerCamelCase_							  =					"""google/owlvit-base-patch32"""
												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(__UpperCamelCase   )

												lowerCamelCase_							  =					["""cat""", """nasa badge"""]
												lowerCamelCase_							  =					processor(text=__UpperCamelCase   )

												lowerCamelCase_							  =					1_6
												self.assertListEqual(list(inputs.keys()   )   ,					["""input_ids""", """attention_mask"""]   )
												self.assertEqual(inputs["""input_ids"""].shape   ,					(2, seq_length)   )

												# test if it raises when no input is passed
												with pytest.raises(__UpperCamelCase   ):
																			processor()

					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_							  =					"""google/owlvit-base-patch32"""
												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(__UpperCamelCase   )

												lowerCamelCase_							  =					[["""cat""", """nasa badge"""], ["""person"""]]
												lowerCamelCase_							  =					processor(text=__UpperCamelCase   )

												lowerCamelCase_							  =					1_6
												lowerCamelCase_							  =					len(__UpperCamelCase   )
												lowerCamelCase_							  =					max([len(__UpperCamelCase   ) for texts in input_texts]   )

												self.assertListEqual(list(inputs.keys()   )   ,					["""input_ids""", """attention_mask"""]   )
												self.assertEqual(inputs["""input_ids"""].shape   ,					(batch_size * num_max_text_queries, seq_length)   )

												# test if it raises when no input is passed
												with pytest.raises(__UpperCamelCase   ):
																			processor()

					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_							  =					"""google/owlvit-base-patch32"""
												lowerCamelCase_							  =					OwlViTProcessor.from_pretrained(__UpperCamelCase   )

												lowerCamelCase_							  =					["""cat""", """nasa badge"""]
												lowerCamelCase_							  =					processor(text=__UpperCamelCase   )

												lowerCamelCase_							  =					1_6
												lowerCamelCase_							  =					inputs["""input_ids"""]
												lowerCamelCase_							  =					[
												    [4_9_4_0_6, 2_3_6_8, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
												    [4_9_4_0_6, 6_8_4_1, 1_1_3_0_1, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
												]

												self.assertListEqual(list(inputs.keys()   )   ,					["""input_ids""", """attention_mask"""]   )
												self.assertEqual(inputs["""input_ids"""].shape   ,					(2, seq_length)   )
												self.assertListEqual(list(input_ids[0]   )   ,					predicted_ids[0]   )
												self.assertListEqual(list(input_ids[1]   )   ,					predicted_ids[1]   )

					def    lowercase__      (	self					:     int   ):
												lowerCamelCase_							  =					self.get_image_processor()
												lowerCamelCase_							  =					self.get_tokenizer()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )

												lowerCamelCase_							  =					self.prepare_image_inputs()
												lowerCamelCase_							  =					self.prepare_image_inputs()

												lowerCamelCase_							  =					processor(images=__UpperCamelCase   ,					query_images=__UpperCamelCase   )

												self.assertListEqual(list(inputs.keys()   )   ,					["""query_pixel_values""", """pixel_values"""]   )

												# test if it raises when no input is passed
												with pytest.raises(__UpperCamelCase   ):
																			processor()



					def    lowercase__      (	self					:     Dict   ):
												lowerCamelCase_							  =					self.get_image_processor()
												lowerCamelCase_							  =					self.get_tokenizer()

												lowerCamelCase_							  =					OwlViTProcessor(tokenizer=__UpperCamelCase   ,					image_processor=__UpperCamelCase   )

												lowerCamelCase_							  =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

												lowerCamelCase_							  =					processor.batch_decode(__UpperCamelCase   )
												lowerCamelCase_							  =					tokenizer.batch_decode(__UpperCamelCase   )

												self.assertListEqual(__UpperCamelCase   ,					__UpperCamelCase   )





