





'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin







class   A_	(  lowerCAmelCase_							,						unittest.TestCase			):
 _lowerCamelCase  : str           =							CanineTokenizer
 _lowerCamelCase  : Tuple           =							False




 def      lowercase	(					self       :    List[Any]    ):
      super().setUp()
      _UpperCAmelCase     							=   CanineTokenizer()
      tokenizer.save_pretrained(self.tmpdirname    )




 @cached_property
 def      lowercase	(					self       :    List[str]    ):
      return CanineTokenizer.from_pretrained("google/canine-s"    )




 def      lowercase	(					self       :    Union[str, Any]	,			**snake_case_       :    List[Any]    ):
      _UpperCAmelCase     							=   self.tokenizer_class.from_pretrained(self.tmpdirname	,			**snake_case_    )
      _UpperCAmelCase     							=   1_0_2_4
      return tokenizer




 @require_torch
 def      lowercase	(					self       :    List[str]    ):
      _UpperCAmelCase     							=   self.canine_tokenizer
      _UpperCAmelCase     							=   ["Life is like a box of chocolates.", "You never know what you're gonna get."]
      # fmt: off
      _UpperCAmelCase     							=   [5_7_3_4_4, 7_6, 1_0_5, 1_0_2, 1_0_1, 3_2, 1_0_5, 1_1_5, 3_2, 1_0_8, 1_0_5, 1_0_7, 1_0_1, 3_2, 9_7, 3_2, 9_8, 1_1_1, 1_2_0, 3_2, 1_1_1, 1_0_2, 3_2, 9_9, 1_0_4, 1_1_1, 9_9, 1_1_1, 1_0_8, 9_7, 1_1_6, 1_0_1, 1_1_5, 4_6, 5_7_3_4_5, 0, 0, 0, 0]
      # fmt: on
      _UpperCAmelCase     							=   tokenizer(snake_case_	,			padding=snake_case_	,			return_tensors="pt"    )
      self.assertIsInstance(snake_case_	,			snake_case_    )

      _UpperCAmelCase     							=   list(batch.input_ids.numpy()[0]    )

      self.assertListEqual(snake_case_	,			snake_case_    )

      self.assertEqual((2, 3_9)	,			batch.input_ids.shape    )
      self.assertEqual((2, 3_9)	,			batch.attention_mask.shape    )




 @require_torch
 def      lowercase	(					self       :    List[Any]    ):
      _UpperCAmelCase     							=   self.canine_tokenizer
      _UpperCAmelCase     							=   ["Once there was a man.", "He wrote a test in HuggingFace Tranformers."]
      _UpperCAmelCase     							=   tokenizer(snake_case_	,			padding=snake_case_	,			return_tensors="pt"    )
      # check if input_ids, attention_mask and token_type_ids are returned
      self.assertIn("input_ids"	,			snake_case_    )
      self.assertIn("attention_mask"	,			snake_case_    )
      self.assertIn("token_type_ids"	,			snake_case_    )




 @require_torch
 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   self.canine_tokenizer
      _UpperCAmelCase     							=   [
          "What's the weater?",
          "It's about 25 degrees.",
      ]
      _UpperCAmelCase     							=   tokenizer(
          text_target=snake_case_	,			max_length=3_2	,			padding="max_length"	,			truncation=snake_case_	,			return_tensors="pt"    )
      self.assertEqual(3_2	,			targets["input_ids"].shape[1]    )




 def      lowercase	(					self       :    Union[str, Any]    ):
      # safety check on max_len default value so we are sure the test works
      _UpperCAmelCase     							=   self.get_tokenizers()
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                self.assertNotEqual(tokenizer.model_max_length	,			4_2    )

        # Now let's start the test
      _UpperCAmelCase     							=   self.get_tokenizers()
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                # Isolate this from the other tests because we save additional tokens/etc
                _UpperCAmelCase     							=   tempfile.mkdtemp()

                _UpperCAmelCase     							=   " He is very happy, UNwant\u00E9d,running"
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                tokenizer.save_pretrained(snake_case_    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(snake_case_    )
                _UpperCAmelCase     							=   after_tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                self.assertListEqual(snake_case_	,			snake_case_    )

                shutil.rmtree(snake_case_    )

      _UpperCAmelCase     							=   self.get_tokenizers(model_max_length=4_2    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                # Isolate this from the other tests because we save additional tokens/etc
                _UpperCAmelCase     							=   tempfile.mkdtemp()

                _UpperCAmelCase     							=   " He is very happy, UNwant\u00E9d,running"

                _UpperCAmelCase     							=   tokenizer.additional_special_tokens

                # We can add a new special token for Canine as follows:
                _UpperCAmelCase     							=   chr(0Xe0_07    )
                additional_special_tokens.append(snake_case_    )
                tokenizer.add_special_tokens({"additional_special_tokens": additional_special_tokens}    )
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                tokenizer.save_pretrained(snake_case_    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(snake_case_    )
                _UpperCAmelCase     							=   after_tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                self.assertListEqual(snake_case_	,			snake_case_    )
                self.assertIn(snake_case_	,			after_tokenizer.additional_special_tokens    )
                self.assertEqual(after_tokenizer.model_max_length	,			4_2    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(snake_case_	,			model_max_length=4_3    )
                self.assertEqual(tokenizer.model_max_length	,			4_3    )

                shutil.rmtree(snake_case_    )




 def      lowercase	(					self       :    int    ):
      _UpperCAmelCase     							=   self.get_tokenizers(do_lower_case=snake_case_    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                _UpperCAmelCase							,  _UpperCAmelCase     							=   self.get_clean_sequence(snake_case_    )

                # a special token for Canine can be defined as follows:
                _UpperCAmelCase     							=   0Xe0_05
                _UpperCAmelCase     							=   chr(snake_case_    )

                tokenizer.add_special_tokens({"cls_token": special_token}    )
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                self.assertEqual(len(snake_case_    )	,			1    )

                _UpperCAmelCase     							=   tokenizer.decode(ids + encoded_special_token	,			clean_up_tokenization_spaces=snake_case_    )
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )

                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                self.assertEqual(snake_case_	,			input_encoded + special_token_id    )

                _UpperCAmelCase     							=   tokenizer.decode(snake_case_	,			skip_special_tokens=snake_case_    )
                self.assertTrue(special_token not in decoded    )




 def      lowercase	(					self       :    int    ):
      _UpperCAmelCase     							=   self.get_tokenizers(do_lower_case=snake_case_    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                _UpperCAmelCase     							=   chr(0Xe0_05    )
                _UpperCAmelCase     							=   chr(0Xe0_06    )

                # `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
                tokenizer.add_tokens([SPECIAL_TOKEN_1]	,			special_tokens=snake_case_    )
                # `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
                # which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
                tokenizer.add_special_tokens({"additional_special_tokens": [SPECIAL_TOKEN_2]}    )

                _UpperCAmelCase     							=   tokenizer.tokenize(snake_case_    )
                _UpperCAmelCase     							=   tokenizer.tokenize(snake_case_    )

                self.assertEqual(len(snake_case_    )	,			1    )
                self.assertEqual(len(snake_case_    )	,			1    )
                self.assertEqual(token_a[0]	,			snake_case_    )
                self.assertEqual(token_a[0]	,			snake_case_    )




 @require_tokenizers
 def      lowercase	(					self       :    Any    ):
      _UpperCAmelCase     							=   self.get_tokenizers(do_lower_case=snake_case_    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                # a special token for Canine can be defined as follows:
                _UpperCAmelCase     							=   0Xe0_06
                _UpperCAmelCase     							=   chr(snake_case_    )

                _UpperCAmelCase     							=   AddedToken(snake_case_	,			lstrip=snake_case_    )
                tokenizer.add_special_tokens({"additional_special_tokens": [new_token]}    )

                with tempfile.TemporaryDirectory() as tmp_dir_name:
                     tokenizer.save_pretrained(snake_case_    )
                     tokenizer.from_pretrained(snake_case_    )




 def      lowercase	(					self       :    List[Any]    ):
      _UpperCAmelCase     							=   []
      if self.test_slow_tokenizer:
           tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())    )

      if self.test_rust_tokenizer:
           tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())    )

      for tokenizer_class, tokenizer_utils in tokenizer_list:
           with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer_utils.save_pretrained(snake_case_    )

                with open(os.path.join(snake_case_	,			"special_tokens_map.json"    )	,			encoding="utf-8"    ) as json_file:
                     _UpperCAmelCase     							=   json.load(snake_case_    )

                with open(os.path.join(snake_case_	,			"tokenizer_config.json"    )	,			encoding="utf-8"    ) as json_file:
                     _UpperCAmelCase     							=   json.load(snake_case_    )

                # a special token for Canine can be defined as follows:
                _UpperCAmelCase     							=   0Xe0_06
                _UpperCAmelCase     							=   chr(snake_case_    )

                _UpperCAmelCase     							=   [new_token_a]
                _UpperCAmelCase     							=   [new_token_a]

                with open(os.path.join(snake_case_	,			"special_tokens_map.json"    )	,			"w"	,			encoding="utf-8"    ) as outfile:
                     json.dump(snake_case_	,			snake_case_    )
                with open(os.path.join(snake_case_	,			"tokenizer_config.json"    )	,			"w"	,			encoding="utf-8"    ) as outfile:
                     json.dump(snake_case_	,			snake_case_    )

                # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                # "special_tokens_map.json" files
                _UpperCAmelCase     							=   tokenizer_class.from_pretrained(snake_case_	,			extra_ids=0    )
                self.assertIn(snake_case_	,			tokenizer_without_change_in_init.additional_special_tokens    )
                # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
                self.assertEqual(
                    [new_token_a]	,			tokenizer_without_change_in_init.convert_ids_to_tokens(
                        tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]    )    )	,			)

                _UpperCAmelCase     							=   0Xe0_07
                _UpperCAmelCase     							=   chr(snake_case_    )
                # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                _UpperCAmelCase     							=   [AddedToken(snake_case_	,			lstrip=snake_case_    )]
                _UpperCAmelCase     							=   tokenizer_class.from_pretrained(
                    snake_case_	,			additional_special_tokens=snake_case_	,			extra_ids=0    )

                self.assertIn(snake_case_	,			tokenizer.additional_special_tokens    )
                # self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
                self.assertEqual(
                    [new_token_a]	,			tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]    )    )    )




 @require_tokenizers
 def      lowercase	(					self       :    Tuple    ):
      _UpperCAmelCase     							=   self.get_tokenizers(do_lower_case=snake_case_    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                _UpperCAmelCase     							=   "hello world"
                if self.space_between_special_tokens:
                     _UpperCAmelCase     							=   "[CLS] hello world [SEP]"
                else:
                     _UpperCAmelCase     							=   input
                _UpperCAmelCase     							=   tokenizer.encode(snake_case_	,			add_special_tokens=snake_case_    )
                _UpperCAmelCase     							=   tokenizer.decode(snake_case_	,			spaces_between_special_tokens=self.space_between_special_tokens    )
                self.assertIn(snake_case_	,			[output, output.lower()]    )




 def      lowercase	(					self       :    str    ):
      _UpperCAmelCase     							=   self.get_tokenizers()
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                _UpperCAmelCase     							=   [
                    "bos_token",
                    "eos_token",
                    "unk_token",
                    "sep_token",
                    "pad_token",
                    "cls_token",
                    "mask_token",
                ]

      _UpperCAmelCase     							=   "a"
      _UpperCAmelCase     							=   ord(snake_case_    )

      for attr in attributes_list:
           setattr(snake_case_	,			attr + "_id"	,			snake_case_    )
           self.assertEqual(getattr(snake_case_	,			snake_case_    )	,			snake_case_    )
           self.assertEqual(getattr(snake_case_	,			attr + "_id"    )	,			snake_case_    )

           setattr(snake_case_	,			attr + "_id"	,			snake_case_    )
           self.assertEqual(getattr(snake_case_	,			snake_case_    )	,			snake_case_    )
           self.assertEqual(getattr(snake_case_	,			attr + "_id"    )	,			snake_case_    )

      setattr(snake_case_	,			"additional_special_tokens_ids"	,			[]    )
      self.assertListEqual(getattr(snake_case_	,			"additional_special_tokens"    )	,			[]    )
      self.assertListEqual(getattr(snake_case_	,			"additional_special_tokens_ids"    )	,			[]    )

      _UpperCAmelCase     							=   0Xe0_06
      _UpperCAmelCase     							=   chr(snake_case_    )
      setattr(snake_case_	,			"additional_special_tokens_ids"	,			[additional_special_token_id]    )
      self.assertListEqual(getattr(snake_case_	,			"additional_special_tokens"    )	,			[additional_special_token]    )
      self.assertListEqual(getattr(snake_case_	,			"additional_special_tokens_ids"    )	,			[additional_special_token_id]    )




 def      lowercase	(					self       :    Any    ):
      pass




 def      lowercase	(					self       :    List[Any]    ):
      pass




 def      lowercase	(					self       :    Union[str, Any]    ):
      pass




 def      lowercase	(					self       :    List[Any]    ):
      pass




 def      lowercase	(					self       :    List[Any]    ):
      pass




 def      lowercase	(					self       :    int    ):
      pass




 def      lowercase	(					self       :    int    ):
      pass




 def      lowercase	(					self       :    Optional[Any]    ):
      pass






"""simple docstring"""



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
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 TFResNetForImageClassification, TFResNetModel
 from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor

class       lowerCAmelCase__				:







     def __init__(							self			:			Dict    ,      _lowerCamelCase			:			int    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			List[str]=32    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			Dict=10    ,      _lowerCamelCase			:			Tuple=[10, 20, 30, 40]    ,      _lowerCamelCase			:			int=[1, 1, 2, 1]    ,      _lowerCamelCase			:			int=True    ,      _lowerCamelCase			:			Optional[int]=True    ,      _lowerCamelCase			:			Optional[int]="relu"    ,      _lowerCamelCase			:			List[Any]=3    ,      _lowerCamelCase			:			Dict=None    ,      ):
       _snake_case					     =       parent
       _snake_case					     =       batch_size
       _snake_case					     =       image_size
       _snake_case					     =       num_channels
       _snake_case					     =       embeddings_size
       _snake_case					     =       hidden_sizes
       _snake_case					     =       depths
       _snake_case					     =       is_training
       _snake_case					     =       use_labels
       _snake_case					     =       hidden_act
       _snake_case					     =       num_labels
       _snake_case					     =       scope
       _snake_case					     =       len(_lowerCamelCase			)







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

       _snake_case					     =       self.get_config()

       return config, pixel_values, labels







     def      lowercase	(							self			:			Tuple			):
       return ResNetConfig(
           num_channels=self.num_channels    ,      embeddings_size=self.embeddings_size    ,      hidden_sizes=self.hidden_sizes    ,      depths=self.depths    ,      hidden_act=self.hidden_act    ,      num_labels=self.num_labels    ,      image_size=self.image_size    ,      )







     def      lowercase	(							self			:			List[Any]    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			List[Any]			):
       _snake_case					     =       TFResNetModel(config=_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase			)
       # expected last hidden states: B, C, H // 32, W // 32
       self.parent.assertEqual(
           result.last_hidden_state.shape    ,      (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,      )







     def      lowercase	(							self			:			Dict    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			Optional[Any]    ,      _lowerCamelCase			:			Tuple			):
       _snake_case					     =       self.num_labels
       _snake_case					     =       TFResNetForImageClassification(_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase    ,      labels=_lowerCamelCase			)
       self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)			)







     def      lowercase	(							self			:			Tuple			):
       _snake_case					     =       self.prepare_config_and_inputs()
       _snake_case     ,					_snake_case     ,					_snake_case					     =       config_and_inputs
       _snake_case					     =       {'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_tf
class       lowerCAmelCase__				(						A_ ,	A_ ,	unittest.TestCase	):
     __a						=					(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     __a						=					(
         {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetModelTester(self			)
       _snake_case					     =       ConfigTester(self    ,      config_class=_lowerCamelCase    ,      has_text_modality=_lowerCamelCase			)







     def      lowercase	(							self			:			Tuple			):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()







     def      lowercase	(							self			:			List[Any]			):
       return







     @unittest.skip(reason='''ResNet does not use inputs_embeds'''			)
     def      lowercase	(							self			:			Any			):
       pass







     @unittest.skip(reason='''ResNet does not support input and output embeddings'''			)
     def      lowercase	(							self			:			List[str]			):
       pass







     def      lowercase	(							self			:			int			):
       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()

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

         _snake_case					     =       ['''pixel_values''']
         self.assertListEqual(arg_names[:1]    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       def check_hidden_states_output(_lowerCamelCase			:			int    ,      _lowerCamelCase			:			List[Any]    ,      _lowerCamelCase			:			str			):
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       model(**self._prepare_for_class(_lowerCamelCase    ,      _lowerCamelCase			)			)

         _snake_case					     =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         _snake_case					     =       self.model_tester.num_stages
         self.assertEqual(len(_lowerCamelCase			)    ,      expected_num_stages + 1			)

         # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]			)    ,      [self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,      )

       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()
       _snake_case					     =       ['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
         for layer_type in layers_type:
           _snake_case					     =       layer_type
           _snake_case					     =       True
           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)

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

           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase			)







     @slow
     def      lowercase	(							self			:			List[str]			):
       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _snake_case					     =       TFResNetModel.from_pretrained(_lowerCamelCase			)
         self.assertIsNotNone(_lowerCamelCase			)






def 					_UpperCAmelCase      ( )     ->					Union[str, Any]:
  _snake_case					     =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
  return image

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







     @cached_property
     def      lowercase	(							self			:			Dict			):
       return (
           AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
           if is_vision_available()
           else None
       )







     @slow
     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

       _snake_case					     =       self.default_image_processor
       _snake_case					     =       prepare_img()
       _snake_case					     =       image_processor(images=_lowerCamelCase    ,      return_tensors='''tf'''			)

       # forward pass
       _snake_case					     =       model(**_lowerCamelCase			)

       # verify the logits
       _snake_case					     =       tf.TensorShape((1, 1000)			)
       self.assertEqual(outputs.logits.shape    ,      _lowerCamelCase			)

       _snake_case					     =       tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]			)

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



