


import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase			=							logging.get_logger(__name__)

__lowerCAmelCase			=							{
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

__lowerCAmelCase			=							{
    '''b0''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 2_24,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 2_40,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 14_08,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 2_60,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 15_36,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 3_00,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 17_92,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 3_80,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 20_48,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 4_56,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 23_04,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 5_28,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 25_60,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 6_00,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}




def        snake_case_					(  snake_case					)  ->    Any:
       lowercase__:       Optional[int]        =       EfficientNetConfig()
       lowercase__:       Union[str, Any]        =       CONFIG_MAP[model_name]['hidden_dim']
       lowercase__:       Dict        =       CONFIG_MAP[model_name]['width_coef']
       lowercase__:       Any        =       CONFIG_MAP[model_name]['depth_coef']
       lowercase__:       Optional[Any]        =       CONFIG_MAP[model_name]['image_size']
       lowercase__:       List[Any]        =       CONFIG_MAP[model_name]['dropout_rate']
       lowercase__:       Optional[Any]        =       CONFIG_MAP[model_name]['dw_padding']

       lowercase__:       Any        =       'huggingface/label-files'
       lowercase__:       Tuple        =       'imagenet-1k-id2label.json'
       lowercase__:       str        =       10_00
       lowercase__:       List[str]        =       json.load(open(hf_hub_download(snake_case      ,							snake_case      ,							repo_type='dataset'					)      ,							'r'					)					)
       lowercase__:       Optional[Any]        =       {int(snake_case					): v for k, v in idalabel.items()}

       lowercase__:       Tuple        =       idalabel
       lowercase__:       List[str]        =       {v: k for k, v in idalabel.items()}
       return config




def        snake_case_					(  )  ->    Union[str, Any]:
       lowercase__:       int        =       'http://images.cocodataset.org/val2017/000000039769.jpg'
       lowercase__:       Union[str, Any]        =       Image.open(requests.get(snake_case      ,							stream=snake_case					).raw					)
       return im




def        snake_case_					(  snake_case					)  ->    List[str]:
       lowercase__:       Any        =       CONFIG_MAP[model_name]['image_size']
       lowercase__:       Any        =       EfficientNetImageProcessor(
           size={'height': size, 'width': size}      ,							image_mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]      ,							image_std=[0.4_7_8_5_3_9_4_4, 0.4_7_3_2_8_6_4, 0.4_7_4_3_4_1_6_3]      ,							do_center_crop=snake_case      ,							)
       return preprocessor




def        snake_case_					(  snake_case					)  ->    List[str]:
       lowercase__:       Any        =       [v.split('_'					)[0].split('block'					)[1] for v in original_param_names if v.startswith('block'					)]
       lowercase__:       Optional[Any]        =       sorted(set(snake_case					)					)
       lowercase__:       int        =       len(snake_case					)
       lowercase__:       str        =       {b: str(snake_case					) for b, i in zip(snake_case      ,							range(snake_case					)					)}

       lowercase__:       List[str]        =       []
       rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight')					)
       rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight')					)
       rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias')					)
       rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean')					)
       rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var')					)

       for b in block_names:
              lowercase__:       Optional[Any]        =       block_name_mapping[b]
              rename_keys.append((f'block{b}_expand_conv/kernel:0', f'encoder.blocks.{hf_b}.expansion.expand_conv.weight')					)
              rename_keys.append((f'block{b}_expand_bn/gamma:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.weight')					)
              rename_keys.append((f'block{b}_expand_bn/beta:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.bias')					)
              rename_keys.append(
                  (f'block{b}_expand_bn/moving_mean:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.running_mean')					)
              rename_keys.append(
                  (f'block{b}_expand_bn/moving_variance:0', f'encoder.blocks.{hf_b}.expansion.expand_bn.running_var')					)
              rename_keys.append(
                  (f'block{b}_dwconv/depthwise_kernel:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight')					)
              rename_keys.append((f'block{b}_bn/gamma:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight')					)
              rename_keys.append((f'block{b}_bn/beta:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias')					)
              rename_keys.append(
                  (f'block{b}_bn/moving_mean:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean')					)
              rename_keys.append(
                  (f'block{b}_bn/moving_variance:0', f'encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var')					)

              rename_keys.append((f'block{b}_se_reduce/kernel:0', f'encoder.blocks.{hf_b}.squeeze_excite.reduce.weight')					)
              rename_keys.append((f'block{b}_se_reduce/bias:0', f'encoder.blocks.{hf_b}.squeeze_excite.reduce.bias')					)
              rename_keys.append((f'block{b}_se_expand/kernel:0', f'encoder.blocks.{hf_b}.squeeze_excite.expand.weight')					)
              rename_keys.append((f'block{b}_se_expand/bias:0', f'encoder.blocks.{hf_b}.squeeze_excite.expand.bias')					)
              rename_keys.append(
                  (f'block{b}_project_conv/kernel:0', f'encoder.blocks.{hf_b}.projection.project_conv.weight')					)
              rename_keys.append((f'block{b}_project_bn/gamma:0', f'encoder.blocks.{hf_b}.projection.project_bn.weight')					)
              rename_keys.append((f'block{b}_project_bn/beta:0', f'encoder.blocks.{hf_b}.projection.project_bn.bias')					)
              rename_keys.append(
                  (f'block{b}_project_bn/moving_mean:0', f'encoder.blocks.{hf_b}.projection.project_bn.running_mean')					)
              rename_keys.append(
                  (f'block{b}_project_bn/moving_variance:0', f'encoder.blocks.{hf_b}.projection.project_bn.running_var')					)

       rename_keys.append(('top_conv/kernel:0', 'encoder.top_conv.weight')					)
       rename_keys.append(('top_bn/gamma:0', 'encoder.top_bn.weight')					)
       rename_keys.append(('top_bn/beta:0', 'encoder.top_bn.bias')					)
       rename_keys.append(('top_bn/moving_mean:0', 'encoder.top_bn.running_mean')					)
       rename_keys.append(('top_bn/moving_variance:0', 'encoder.top_bn.running_var')					)

       lowercase__:       Dict        =       {}
       for item in rename_keys:
              if item[0] in original_param_names:
                     lowercase__:       Dict        =       'efficientnet.' + item[1]

       lowercase__:       Any        =       'classifier.weight'
       lowercase__:       Any        =       'classifier.bias'
       return key_mapping




def        snake_case_					(  snake_case      ,							snake_case      ,							snake_case					)  ->    Tuple:
       for key, value in tf_params.items():
              if "normalization" in key:
                     continue

              lowercase__:       Union[str, Any]        =       key_mapping[key]
              if "_conv" in key and "kernel" in key:
                     lowercase__:       Optional[Any]        =       torch.from_numpy(snake_case					).permute(3      ,							2      ,							0      ,							1					)
              elif "depthwise_kernel" in key:
                     lowercase__:       Any        =       torch.from_numpy(snake_case					).permute(2      ,							3      ,							0      ,							1					)
              elif "kernel" in key:
                     lowercase__:       List[str]        =       torch.from_numpy(np.transpose(snake_case					)					)
              else:
                     lowercase__:       Any        =       torch.from_numpy(snake_case					)

              # Replace HF parameters with original TF model parameters
              assert hf_params[hf_key].shape == new_hf_value.shape
              hf_params[hf_key].copy_(snake_case					)




@torch.no_grad()
def        snake_case_					(  snake_case      ,							snake_case      ,							snake_case      ,							snake_case					)  ->    int:
       lowercase__:       int        =       model_classes[model_name](
           include_top=snake_case      ,							weights='imagenet'      ,							input_tensor=snake_case      ,							input_shape=snake_case      ,							pooling=snake_case      ,							classes=10_00      ,							classifier_activation='softmax'      ,							)

       lowercase__:       Dict        =       original_model.trainable_variables
       lowercase__:       List[str]        =       original_model.non_trainable_variables
       lowercase__:       str        =       {param.name: param.numpy() for param in tf_params}
       for param in tf_non_train_params:
              lowercase__:       Any        =       param.numpy()
       lowercase__:       Dict        =       list(tf_params.keys()					)

       # Load HuggingFace model
       lowercase__:       Optional[Any]        =       get_efficientnet_config(snake_case					)
       lowercase__:       str        =       EfficientNetForImageClassification(snake_case					).eval()
       lowercase__:       Optional[Any]        =       hf_model.state_dict()

       # Create src-to-dst parameter name mapping dictionary
       print('Converting parameters...'					)
       lowercase__:       Tuple        =       rename_keys(snake_case					)
       replace_params(snake_case      ,							snake_case      ,							snake_case					)

       # Initialize preprocessor and preprocess input image
       lowercase__:       int        =       convert_image_processor(snake_case					)
       lowercase__:       List[str]        =       preprocessor(images=prepare_img()      ,							return_tensors='pt'					)

       # HF model inference
       hf_model.eval()
       with torch.no_grad():
              lowercase__:       str        =       hf_model(**snake_case					)
       lowercase__:       List[Any]        =       outputs.logits.detach().numpy()

       # Original model inference
       lowercase__:       Tuple        =       False
       lowercase__:       Tuple        =       CONFIG_MAP[model_name]['image_size']
       lowercase__:       str        =       prepare_img().resize((image_size, image_size)      ,							resample=PIL.Image.NEAREST					)
       lowercase__:       Union[str, Any]        =       image.img_to_array(snake_case					)
       lowercase__:       Tuple        =       np.expand_dims(snake_case      ,							axis=0					)
       lowercase__:       Optional[int]        =       original_model.predict(snake_case					)

       # Check whether original and HF model outputs match  -> np.allclose
       assert np.allclose(snake_case      ,							snake_case      ,							atol=1e-3					), "The predicted logits are not the same."
       print('Model outputs match!'					)

       if save_model:
              # Create folder to save model
              if not os.path.isdir(snake_case					):
                     os.mkdir(snake_case					)
              # Save converted model and image processor
              hf_model.save_pretrained(snake_case					)
              preprocessor.save_pretrained(snake_case					)

       if push_to_hub:
              # Push model and image processor to hub
              print(f'Pushing converted {model_name} to the hub...'					)
              lowercase__:       Optional[Any]        =       f'efficientnet-{model_name}'
              preprocessor.push_to_hub(snake_case					)
              hf_model.push_to_hub(snake_case					)


if __name__ == "__main__":
  __lowerCAmelCase			=							argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--model_name''',
      default='''b0''',
      type=str,
      help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''',
      default='''hf_model''',
      type=str,
      help='''Path to the output PyTorch model directory.''',
  )
  parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
  parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

  __lowerCAmelCase			=							parser.parse_args()
  convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)






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   __a      (   __UpperCamelCase	,	unittest.TestCase				):
 __lowercase			:							Optional[int]       					=			CLIPTokenizer
 __lowercase			:							str       					=			CLIPTokenizerFast
 __lowercase			:							Tuple       					=			True
 __lowercase			:							str       					=			{}
 __lowercase			:							Dict       					=			False
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    int:




        '''simple docstring'''
        super().setUp()

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

        lowercase__:       int        =       os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['vocab_file']			)
        lowercase__:       Union[str, Any]        =       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 		SCREAMING_SNAKE_CASE__       (       self    ,			**lowerCAmelCase__			) ->    List[str]:




        '''simple docstring'''
        kwargs.update(self.special_tokens_map			)
        return CLIPTokenizer.from_pretrained(self.tmpdirname    ,			**lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			**lowerCAmelCase__			) ->    Optional[int]:




        '''simple docstring'''
        kwargs.update(self.special_tokens_map			)
        return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,			**lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Dict        =       'lower newer'
        lowercase__:       Dict        =       'lower newer'
        return input_text, output_text
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       CLIPTokenizer(self.vocab_file    ,			self.merges_file    ,			**self.special_tokens_map			)
        lowercase__:       Dict        =       'lower newer'
        lowercase__:       Union[str, Any]        =       ['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
        lowercase__:       Any        =       tokenizer.tokenize(lowerCAmelCase__			)
        self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

        lowercase__:       Tuple        =       tokens + [tokenizer.unk_token]
        lowercase__:       Tuple        =       [10, 2, 16, 9, 3, 2, 16, 20]
        self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__			)    ,			lowerCAmelCase__			)
 @require_ftfy
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'			):
                      lowercase__:       List[str]        =       self.tokenizer_class.from_pretrained(lowerCAmelCase__    ,			**lowerCAmelCase__			)
                      lowercase__:       Optional[int]        =       self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__    ,			**lowerCAmelCase__			)

                      lowercase__:       Optional[int]        =       'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
                      lowercase__:       Optional[Any]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                      lowercase__:       Dict        =       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
                      lowercase__:       Dict        =       'xa\u0303y' + ' ' + 'x\xe3y'
                      lowercase__:       Tuple        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                      lowercase__:       int        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                      self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

                      # Test that the tokenization is identical on unicode of space type
                      lowercase__:       str        =       [
                          '\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:
                             lowercase__:       Optional[Any]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                             lowercase__:       Tuple        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                             self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

                      # Test that the tokenization is identical on unicode of line break type
                      lowercase__:       str        =       [
                          '\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:
                             lowercase__:       Optional[int]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                             lowercase__:       Optional[int]        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                             self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[int]:




        '''simple docstring'''
        # 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})'			):
                      lowercase__:       Optional[int]        =       'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
                      lowercase__:       Optional[int]        =       F'{text_of_1_token} {text_of_1_token}'

                      lowercase__:       int        =       self.rust_tokenizer_class.from_pretrained(
                          lowerCAmelCase__    ,			use_fast=lowerCAmelCase__    ,			)
                      lowercase__:       Dict        =       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__			))    ,			)

                      lowercase__:       Any        =       F' {text}'

                      lowercase__:       Union[str, Any]        =       self.rust_tokenizer_class.from_pretrained(
                          lowerCAmelCase__    ,			use_fast=lowerCAmelCase__    ,			)
                      lowercase__:       int        =       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[str]:




        '''simple docstring'''
        # 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 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        super().test_tokenization_python_rust_equals()
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        # CLIP always lower cases letters
        pass


