
"""simple docstring"""



import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class       lowerCAmelCase__				(						A_ ,	unittest.TestCase	):
     __a						=					CLIPTokenizer
     __a						=					CLIPTokenizerFast
     __a						=					True
     __a						=					{}
     __a						=					False







     def      lowercase	(							self			:			List[str]			):
       super().setUp()

       # fmt: off
       _snake_case					     =       ['''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
       _snake_case					     =       dict(zip(_lowerCamelCase    ,      range(len(_lowerCamelCase			)			)			)			)
       _snake_case					     =       ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
       _snake_case					     =       {'''unk_token''': '''<unk>'''}

       _snake_case					     =       os.path.join(self.tmpdirname    ,      VOCAB_FILES_NAMES['''vocab_file''']			)
       _snake_case					     =       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(_lowerCamelCase			) + '''\n'''			)
       with open(self.merges_file    ,      '''w'''    ,      encoding='''utf-8'''			) as fp:
         fp.write('''\n'''.join(_lowerCamelCase			)			)







     def      lowercase	(							self			:			Optional[Any]    ,      **_lowerCamelCase			:			Optional[Any]			):
       kwargs.update(self.special_tokens_map			)
       return CLIPTokenizer.from_pretrained(self.tmpdirname    ,      **_lowerCamelCase			)







     def      lowercase	(							self			:			int    ,      **_lowerCamelCase			:			Dict			):
       kwargs.update(self.special_tokens_map			)
       return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,      **_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]    ,      _lowerCamelCase			:			List[str]			):
       _snake_case					     =       '''lower newer'''
       _snake_case					     =       '''lower newer'''
       return input_text, output_text







     def      lowercase	(							self			:			Optional[Any]			):
       _snake_case					     =       CLIPTokenizer(self.vocab_file    ,      self.merges_file    ,      **self.special_tokens_map			)
       _snake_case					     =       '''lower newer'''
       _snake_case					     =       ['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
       _snake_case					     =       tokenizer.tokenize(_lowerCamelCase			)
       self.assertListEqual(_lowerCamelCase    ,      _lowerCamelCase			)

       _snake_case					     =       tokens + [tokenizer.unk_token]
       _snake_case					     =       [10, 2, 16, 9, 3, 2, 16, 20]
       self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase			)    ,      _lowerCamelCase			)







     @require_ftfy
     def      lowercase	(							self			:			Any			):
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
           _snake_case					     =       self.tokenizer_class.from_pretrained(_lowerCamelCase    ,      **_lowerCamelCase			)
           _snake_case					     =       self.rust_tokenizer_class.from_pretrained(_lowerCamelCase    ,      **_lowerCamelCase			)

           _snake_case					     =       '''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
           _snake_case					     =       tokenizer_s.tokenize(_lowerCamelCase			)
           _snake_case					     =       tokenizer_r.tokenize(_lowerCamelCase			)

           self.assertListEqual(_lowerCamelCase    ,      _lowerCamelCase			)

           # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
           # with Tilde) encoded in 2 different ways
           _snake_case					     =       '''xa\u0303y''' + ''' ''' + '''x\xe3y'''
           _snake_case					     =       tokenizer_s.tokenize(_lowerCamelCase			)
           _snake_case					     =       tokenizer_r.tokenize(_lowerCamelCase			)

           self.assertListEqual(_lowerCamelCase    ,      _lowerCamelCase			)

           # Test that the tokenization is identical on unicode of space type
           _snake_case					     =       [
               '''\u0009''',  # (horizontal tab, '\t')
               '''\u000B''',  # (vertical tab)
               '''\u000C''',  # (form feed)
               '''\u0020''',  # (space, ' ')
               '''\u200E''',  # (left-to-right mark):w
               '''\u200F''',  # (right-to-left mark)
           ]
           for unicode_seq in spaces_unicodes:
             _snake_case					     =       tokenizer_s.tokenize(_lowerCamelCase			)
             _snake_case					     =       tokenizer_r.tokenize(_lowerCamelCase			)

             self.assertListEqual(_lowerCamelCase    ,      _lowerCamelCase			)

           # Test that the tokenization is identical on unicode of line break type
           _snake_case					     =       [
               '''\u000A''',  # (line feed, '\n')
               '''\r\n''',  # (carriage return and line feed, '\r\n')
               '''\u000D''',  # (carriage return, '\r')
               '''\r''',  # (carriage return, '\r')
               '''\u000D''',  # (carriage return, '\r')
               '''\u2028''',  # (line separator)
               '''\u2029''',  # (paragraph separator)
               # "\u0085", # (next line)
           ]

           # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
           # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
           # space (and thus into an empty list).

           for unicode_seq in line_break_unicodes:
             _snake_case					     =       tokenizer_s.tokenize(_lowerCamelCase			)
             _snake_case					     =       tokenizer_r.tokenize(_lowerCamelCase			)

             self.assertListEqual(_lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Dict			):
       # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''			):
           _snake_case					     =       '''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
           _snake_case					     =       f'''{text_of_1_token} {text_of_1_token}'''

           _snake_case					     =       self.rust_tokenizer_class.from_pretrained(
               _lowerCamelCase    ,      use_fast=_lowerCamelCase    ,      )
           _snake_case					     =       tokenizer_r(_lowerCamelCase    ,      return_offsets_mapping=_lowerCamelCase    ,      add_special_tokens=_lowerCamelCase			)
           self.assertEqual(encoding.offset_mapping[0]    ,      (0, len(_lowerCamelCase			))			)
           self.assertEqual(
               encoding.offset_mapping[1]    ,      (len(_lowerCamelCase			) + 1, len(_lowerCamelCase			) + 1 + len(_lowerCamelCase			))    ,      )

           _snake_case					     =       f''' {text}'''

           _snake_case					     =       self.rust_tokenizer_class.from_pretrained(
               _lowerCamelCase    ,      use_fast=_lowerCamelCase    ,      )
           _snake_case					     =       tokenizer_r(_lowerCamelCase    ,      return_offsets_mapping=_lowerCamelCase    ,      add_special_tokens=_lowerCamelCase			)
           self.assertEqual(encoding.offset_mapping[0]    ,      (1, 1 + len(_lowerCamelCase			))			)
           self.assertEqual(
               encoding.offset_mapping[1]    ,      (1 + len(_lowerCamelCase			) + 1, 1 + len(_lowerCamelCase			) + 1 + len(_lowerCamelCase			))    ,      )







     def      lowercase	(							self			:			Dict			):
       # Test related to the breaking change introduced in transformers v4.17.0
       # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
       with self.assertRaises(_lowerCamelCase			) as context:
         self.rust_tokenizer_class.from_pretrained('''robot-test/old-clip-tokenizer'''			)

       self.assertTrue(
           context.exception.args[0].startswith(
               '''The `backend_tokenizer` provided does not match the expected format.'''			)			)







     @require_ftfy
     def      lowercase	(							self			:			List[str]			):
       super().test_tokenization_python_rust_equals()







     def      lowercase	(							self			:			List[str]			):
       # CLIP always lower cases letters
       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			)			)



